帮助文档

VisualPytorch发布域名+双服务器以下:
http://nag.visualpytorch.top/static/ (对应114.115.148.27)
http://visualpytorch.top/static/ (对应39.97.209.22)html

1、快速入门

1. 界面介绍

首先打开网址,进入网站的首页。网站有游客游览模式和用户登陆模式,建议先注册登陆一个帐号,也是十分简便的啦,由于这样可使用更多的功能。python

页面头部有三个选项,分别为VisualPytorch, 帮助和联系咱们,VisualPytorch就是主页面,能够进行模型的搭建,帮助页面是本网站的简单教程以及相关知识的讲解,在联系咱们界面,能够给咱们反馈你在使用过程当中的遇到的问题,帮助咱们进步呀。git

2. 组件框

在VisualPytorch界面左侧有可选择的网络层,这些层就是用来搭建神经网络模型的基本组件,在网络层的下面还有训练参数配置,主要用于肯定模型的全局训练参数。下面给你们简单展现一下如何拖拽和删除这些组件框,以及组件框参数的位置。github

3. 生成和下载代码

在VisualPytorch界面左上角有生成代码按钮,当你搭建好本身的神经网络模型以后,就能够点击这个按钮,而后会跳转到代码页面,你也就能够看到生成的代码啦,而后再点击下载代码,就能够把代码下载到本地,畅快的玩耍一番啦。算法

4. 保存模型

考虑到也许后续还要用本身搭建过的模型,因此咱们实现了保存模型这一功能(贴心的团队,有木有),当你搭建好一个模型以后,能够直接选择保存,而后模型就会保存到你的帐号啦,下次你登陆还能够查看本身以前的模型。json

2、使用说明

1. 概述

咱们的网站旨在利用清晰的可视化模型来帮助热爱deep learning的你快速搭建想搭建的模型。canvas

目前支持的神经网络层有:reshape层,全链接层,一维卷积层,二维卷积层; 这些层及其涉及的参数的具体含义都与pytorch官方文档里一致。数组

2. 搭建模型

模型的搭建经过将左侧的各种层模块拖入右侧画布并连线来完成。服务器

  • 首先要将左侧的 开始 按钮拖到右侧画布开始模型的搭建,而后一次将你想加入的层模块拖入到右侧画布中,以后点击模块四周的黑点并拖动至其余模块的黑点位置便可完成层模块的链接,支持层模块的并联。
  • 在各个层模块中,其中一些层须要填入相应参数,须要参数的层模块在点击以后会弹出该层须要的具体参数,填写以后点击确认便可保存该层参数。参数均有输入限制,若存在不合规范的参数输入在点击确认时会显示错误提示,详细的参数要求及层的功能介绍会在下文中介绍。
  • 在确认已经完成模型的搭建并填写完毕相应参数以后,能够点击 生成代码 按钮转到生成模型代码页面,若模型搭建中出现错误则没法正常生成代码并弹出错误提示。同时在完成模型搭建以后,点击 保存 按钮能够将搭建的模型保存在用户的帐户中,须要注意的是,只有注册用户拥有权限保存本身搭建的模型,游客不具备保存模型的权限。

3. 生成的代码介绍

main.py里的代码主要是涉及全局的参数以及训练部分,目前该部分还有待完善。网络

model.py里则主要是搭建的模型代码,整个模型咱们封装成了一个类,类名是 NET。

4. 模型管理

注册用户拥有保存本身搭建的模型并管理的权限,用户能够经过点击页面上显示的用户名,弹出 模型查看 和 登出 选项,点击模型查看便可进入模型管理的页面,该页面会显示用户曾搭建并保存的全部模型,每一个模型都有对应的 查看 和 删除 按钮。点击查看便可进入模型搭建的页面并恢复用户曾保存的模型,用户能够对该模型进行从新编辑。点击删除便可删除相应的模型。

5. 相关的注意事项

  • 搭建神经网络模块须要有显示的开始于结束节点。
  • reshape层里若是有多个维度的话,不一样维度之间须要以英文的逗号分开

3、经典模型

1. VGG_16_layers

VGG卷积神经网络是牛津大学在2014年提出来的模型,它在图像分类和目标检测任务中都表现出很是好的结果。同时,VGG16模型的权重由ImageNet训练而来。

点击在VisualPytorch中查看

2. AlexNet

AlexNet是2012年ImageNet项目的大规模视觉识别挑战中的胜出者,该项目一种巧妙的手法打破了旧观念,开创了计算机视觉的新局面。

点击在VisualPytorch中查看

3. Network in Network(NIN)

一种新型的深度网络结构,它能够加强模型在感觉野内对局部区域的辨别能力。

点击在VisualPytorch中查看

4、网络层及参数

1. 简单网络层

reshape层

返回一个有相同数据但大小不一样的tenser。返回的tenser必须有与原tenser相同的数据和相同数目的元素,但能够有不一样的大小。一个tenser必须是连续的contiguous()才能被查看。

简单来看,view的参数就比如一个矩阵的行和列的值,当为一个数n的时候,则将数据大小变为1xn。

参数:

  • shape <非负整数及-1序列,包括全部非负整数和-1(只有-1是例外),同维度数字之间以英文的“,”分开,例如1,2,3,4,5> 无默认值

全链接层(linear_layer)

class torch.nn.Linear(in_features, out_features, bias=True)

对输入数据作线性变换:y*=*Ax+b

参数:

  • in_features<正整数> - 输入通道数 无默认值
  • out_features<正整数> - 输入通道数 无默认值

形状:

  • 输入:N, in_features)
  • 输出: (N, out_features)

变量:

  • weight -形状为(out_features x in_features)的模块中可学习的权值
  • bias -形状为(out_features)的模块中可学习的偏置

例子:

>>> m = nn.Linear(20, 30)
>>> input = autograd.Variable(torch.randn(128, 20))
>>> output = m(input)
>>> print(output.size())

元素级相加层(element_wise_add_layer)

该层不须要参数,做为几个层之间的衔接,须要注意的是,该函数的输入能够为多个向量。

channel维度拼接层(concatenate_layer)

torch.cat(inputs, dimension=0) → Tensor

在给定维度上对输入的张量序列seq 进行链接操做。

torch.cat()能够看作 torch.split()torch.chunk()的反操做。 cat() 函数能够经过下面例子更好的理解。

参数:

  • dim<非负整数> - 拼接维度 默认值为0

例子:

>>> x = torch.randn(2, 3)
>>> x

 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 2x3]

>>> torch.cat((x, x, x), 0)

 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
 0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 6x3]

>>> torch.cat((x, x, x), 1)

 0.5983 -0.0341  2.4918  0.5983 -0.0341  2.4918  0.5983 -0.0341  2.4918
 1.5981 -0.5265 -0.8735  1.5981 -0.5265 -0.8735  1.5981 -0.5265 -0.8735
[torch.FloatTensor of size 2x9]

softmax层(softmax_layer)

class torch.nn.Softmax(dim=None)

将Softmax函数应用于n维输入Tensor,对它们进行从新缩放,使得n维输出Tensor的元素位于[0,1]范围内而且总和为1。

函数表达式:

Softmax(xi)=exi∑jexjSoftmax(xi)=exi∑jexj

返回:

  • 一个和输入相同尺寸和形状的张量,其值在[0,1]范围内

参数:

  • dim<正整数> - 计算维度 无默认值

例子:

>>> m = nn.Softmax()
>>> input = torch.randn(2, 3)
>>> output = m(input)

dropout层(dropout_layer)

torch.nn.Dropout(p=0.5, inplace=False)

在训练期间,使用伯努利分布的样本以几率p将输入张量的某些元素随机置零。 在每次前向传播时,每一个通道将独立清零。事实证实,这是一种有效的技术,可用于规范化和防止神经元的协同适应。

  • type<下拉框,包括1d/2d/3d> 默认值为2d
  • p<0-1间实数>:置0几率 默认值为0.5

例子:

a = torch.randn(10,1)
>>> tensor([[ 0.0684],
        [-0.2395],
        [ 0.0785],
        [-0.3815],
        [-0.6080],
        [-0.1690],
        [ 1.0285],
        [ 1.1213],
        [ 0.5261],
        [ 1.1664]])
torch.nn.Dropout(0.5)(a)
>>> tensor([[ 0.0000],  
        [-0.0000],  
        [ 0.0000],  
        [-0.7631],  
        [-0.0000],  
        [-0.0000],  
        [ 0.0000],  
        [ 0.0000],  
        [ 1.0521],  
        [ 2.3328]])

2. 卷积层(conv_layer)

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

卷积神经网络中每层卷积层(Convolutional layer)由若干卷积单元组成,每一个卷积单元的参数都是经过反向传播算法最佳化获得的。卷积运算的目的是提取输入的不一样特征,第一层卷积层可能只能提取一些低级的特征如边缘、线条和角等层级,更多层的网路能从低级特征中迭代提取更复杂的特征。

以一维卷积层为例,输入的尺度是(N, C_in,L),输出尺度( N,C_out,L_out)的计算方式:

\[out(N i ​ ,C out j ​ ​ )=bias(C out j ​ ​ )+ k=0 ∑ C in ​ −1 ​ weight(C out j ​ ​ ,k)⋆input(N i ​ ,k) \]

layer_type<下拉框二选一,conv/conv_transpose> - 分别表示卷积与反卷积 默认值为conv

conv和conv_transpose参数相同

  • type:下拉框三选一,选项包括1d/2d/3d 默认值为2d
  • in_channels<正整数> - 输入通道数 无默认值
  • out_channels<正整数> - 输出通道数 无默认值
  • kernel_size <正整数> - 卷积核的尺寸 默认值为3
  • stride<正整数> - 卷积步长 默认值为1
  • dilation<正整数>– 卷积核元素之间的间距,详细描述在这里 默认值为0
  • padding<非负整数> - 输入的每一条边补充0的层数 默认值为0

形状:

  • 输入: (N,Cin,Lin)(N,Cin,Lin)
  • 输出: (N,Cout,Lout)(N,Cout,Lout)
  • 输入输出的计算方式: Lout=floor(Lin+2p−d∗(k−1)−1s+1)Lout=floor(Lin+2p−d∗(k−1)−1s+1)

变量:

  • weight(tensor) - 卷积的权重,大小是(out_channels, in_channels, kernel_size)
  • bias(tensor) - 卷积的偏置系数,大小是(out_channel

例子:

>>> m = nn.Conv1d(16, 33, 3, stride=2)
>>> input = autograd.Variable(torch.randn(20, 16, 50))
>>> output = m(input)

3. 池化层(pool_layer)

在神经网络中,池化函数(Pooling Function)通常将上一层卷积函数的结果做为本身的输入。通过卷积层提取过特征以后,咱们获得的通道数可能会增大不少,也就是说数据的维度会变得更高,这个时候就须要对数据进行池化操做,也就是降维操做。

池化操做是用每一个矩阵的最大值或是平均值来表明这个矩阵,从而实现元素个数的减小,而且最大值和平均值操做可使得特征提取具备“平移不变性”。

layer_type<下拉框三选一,选项包括max_pool, avg_pool, max_unpool > 默认值为max_pool

max_pool

torch.nn.functional.max_pool1d(input, kernel_size, stride=None, padding=0, dilation=1, ceil_mode=False, return_indices=False)

对由几个输入平面组成的输入信号进行最大池化。通常状况下咱们只须要用到type, kernel_size, stride=None, padding=0这些参数。

参数:

  • type:下拉框三选一,选项包括1d/2d/3d 默认值为2d
  • kernel_size <正整数> : 卷积核的尺寸 默认值为2
  • stride <正整数> : 卷积步长默认值为2
  • padding <非负整数> : 补充0的层数 默认值为0

例子:

>>> # pool of square window of size=3, stride=2
>>> m = nn.MaxPool3d(3, stride=2)
>>> # pool of non-square window
>>> m = nn.MaxPool3d((3, 2, 2), stride=(2, 1, 2))
>>> input = torch.randn(20, 16, 50,44, 31)
>>> output = m(input)

avg_pool

torch.nn.functional.avg_pool1d(input, kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True)

对由几个输入平面组成的输入信号进行平均池化。通常状况下咱们只须要用到type, kernel_size, stride=None, padding=0这些参数。

参数:

  • type:下拉框三选一,选项包括1d/2d/3d 默认值为2d
  • kernel_size<正整数> : 卷积核的尺寸 默认值为2
  • stride<正整数> : 卷积步长 默认值为2
  • padding <非负整数> : 补充0的层数 默认值为0
  • ceil_mode:下拉框二选一,ceil/floor 默认值为floor
  • count_include_pad(勾选框,默认为勾选,在json中为True,不然为False):平均计算中包括零填充 默认值为true

例子:

>>> # pool of square window of size=3, stride=2
>>> input = Variable(torch.Tensor([[[1,2,3,4,5,6,7]]]))
>>> F.avg_pool1d(input, kernel_size=3, stride=2)
Variable containing:
(0 ,.,.) =
  2  4  6
[torch.FloatTensor of size 1x1x3]

max_unpool

torch.nn.MaxUnpool1d(kernel_size, stride=None, padding=0)

参数:

  • type(下拉框三选一,选项包括1d/2d/3d) : 卷积形式 默认值为2d
  • kernel_size <正整数> : 卷积核的尺寸 默认值为2
  • stride<正整数> : 卷积步长 默认值为2
  • padding<非负整数> : 补充0的层数 默认值为0

例子:

>>> pool = nn.MaxPool1d(2, stride=2, return_indices=True)
>>> unpool = nn.MaxUnpool1d(2, stride=2)
>>> input = torch.tensor([[[1., 2, 3, 4, 5, 6, 7, 8]]])
>>> output, indices = pool(input)
>>> unpool(output, indices)
tensor([[[ 0.,  2.,  0.,  4.,  0.,  6.,  0., 8.]]])

>>> # Example showcasing the use of output_size
>>> input = torch.tensor([[[1., 2, 3, 4, 5, 6, 7, 8, 9]]])
>>> output, indices = pool(input)
>>> unpool(output, indices, output_size=input.size())
tensor([[[ 0.,  2.,  0.,  4.,  0.,  6.,  0., 8.,  0.]]])

>>> unpool(output, indices)
tensor([[[ 0.,  2.,  0.,  4.,  0.,  6.,  0., 8.]]])

4. 激活层(activation_layer)

激活函数做用在人工神经网络上,负责将神经元的输入映射到输出端。增长了神经网络的非线性,使得神经网络能够任意逼近任意非线性函数,从而使神经网络应用到众多的非线性模型中。

layer_type<下拉框,包括relu/sigmoid/tanh/leaky relu/PRelu/RRelu> 默认值为relu

relu

函数表达式:

\(relu(x)=max(0,x)\)

对应图像:

leaky relu

函数表达式:

\(LeakyRelu(x)=max(x,0) + negative\_slope*min(0,x)\)

参数:

  • negative_slope<正数> - 控制负斜率的角度 **默认值为0.01

对应图像:

sigmoid

函数表达式:

\(sigmoid(x)=\frac{1}{1+e^{-x}}\)

函数图像:

tanh

函数表达式:

\(tanh(x)=\frac{e^x-e^{-x}}{e^x+e^-x}\)

函数图像:

PRelu

torch.nn.PReLU(num_parameters=1, init=0.25)

函数表达式:PReLU(x)=max(0,x)+a∗min(0,x)

函数图像:

相似leaky relu, 可是负数部分斜率可学习

参数:

  • weight<正数> - 权重初始化 非0正实数 默认值为0.25

RRelu

torch.nn.RReLU(lower=0.125, upper=0.3333333333333333, inplace=False)

函数表达式:

相似leaky relu, 可是负数部分斜率为随机均匀分布

参数:

  • lower<正数> - 均匀分布下限 默认值为0.125
  • upper<正数> - 均匀分布上限 默认值为0.333

5. 递归神经网络(RNN_layer)

torch.nn.RNN(*args, **kwargs)

RNN(Recurrent Neural Networks,循环神经网络)不只会学习当前时刻的信息,也会依赖以前的序列信息。因为其特殊的网络模型结构解决了信息保存的问题。因此RNN对处理时间序列和语言文本序列问题有独特的优点。递归神经网络都具备一连串重复神经网络模块的形式。在标准的RNNs中,这种重复模块有一种很是简单的结构。

计算公式:

\[h t ​ =tanh(W ih ​ x t ​ +b ih ​ +W hh ​ h (t−1) ​ +b hh ​ ) \]

具体参数含义:ht是隐藏层在时间t时的状态,xt是时间t时的输入,h(t-1)是隐藏层在t-1时的状态。若是非线性激活函数为relu,那么tanh将用ReLU代替。

参数:

  • input_size<正整数> - 输入特征数 无默认值
  • hidden_size<正整数> - 隐藏层个数 无默认值
  • num_layers<正整数> - 递归层层数 默认值为1
  • nonlinearity<二选一,tanh/relu> - 非线性激活 默认为tanh

6. 长周期神经网络(LSTM_layer)

torch.nn.LSTM(*args, **kwargs)

Long Short Term Memory networks(如下简称LSTMs),一种特殊的RNN网络,该网络设计出来是为了解决长依赖问题。该网络由 [Hochreiter & Schmidhuber (1997)引入,并有许多人对其进行了改进和普及。他们的工做被用来解决了各类各样的问题,直到目前还被普遍应用。

LSTM的计算公式较为复杂,下图截取了pytorch官方文档中的部份内容:

参数:

  • input_size<正整数> - 输入特征数 无默认值
  • hidden_size<正整数> - 隐藏层个数 无默认值
  • num_layers<正整数> - 递归层层数 默认值为1

7. 标准化层(norm_layer)

layer_type<下拉框,选项包括batch_norm/group_norm/instance_norm> 默认值为batch_norm

咱们在对数据训练以前会对数据集进行归一化,归一化的目的归一化的目的就是使得预处理的数据被限定在必定的范围内(好比[0,1]或者[-1,1]),从而消除奇异样本数据致使的不良影响,同时便于加快训练速度。

batch_norm

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

计算公式:

\[y= Var[x]+ϵ ​ x−E[x] ​ ∗γ+β \]

参数:

  • type<下拉框,包括1d/2d/3d> 默认值为2d
  • num_features<正整数>:输入特征数 无默认值

例子:

>>> m = nn.BatchNorm1d(100)
>>> # Without Learnable Parameters
>>> m = nn.BatchNorm1d(100, affine=False)
>>> input = torch.randn(20, 100)
>>> output = m(input)

group_norm

torch.nn.GroupNorm(num_groups, num_channels, eps=1e-05, affine=True)

计算公式:

\[y= Var[x]+ϵ ​ x−E[x] ​ ∗γ+β \]

参数:

  • num_groups<正整数> - input_channel分组数 无默认值
  • num_channel<正整数> - input_channel个数无默认值

例子:

>>> # Separate 6 channels into 3 groups
>>> m = nn.GroupNorm(3, 6)
>>> # Separate 6 channels into 6 groups (equivalent with InstanceNorm)
>>> m = nn.GroupNorm(6, 6)
>>> # Put all 6 channels into a single group (equivalent with LayerNorm)
>>> m = nn.GroupNorm(1, 6)
>>> # Activating the module
>>> output = m(input)

instance_norm

torch.nn.InstanceNorm1d(num_features, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)

计算公式:

\[y= Var[x]+ϵ ​ x−E[x] ​ ∗γ+β \]

参数:

  • type<下拉框,包括1d/2d/3d> 默认值为2d
  • num_features<正整数> - 输入特征数 无默认值

例子:

>>> # Without Learnable Parameters
>>> m = nn.InstanceNorm1d(100)
>>> # With Learnable Parameters
>>> m = nn.InstanceNorm1d(100, affine=True)
>>> input = torch.randn(20, 100, 40)
>>> output = m(input)

1. 简单参数

epoch<正整数> - 全数据集训练次数 默认值为10

当一个完整的数据集经过了神经网络一次而且返回了一次,这个过程称为一次>epoch。(也就是说,全部训练样本在神经网络中 进行了一次正向传播一次反向传播
再通俗一点,一个Epoch就是将全部训练样本训练一次的过程。

learning_rate<0-1内实数> - 学习率 默认值为0.01

学习率(Learning rate)做为监督学习以及深度学习中重要的超参,其决定着目标函数可否收敛到局部最小值以及什么时候收敛到最小值。合适的学习率可以使目标函数在合适的时间内收敛到局部最小值。

batch_size<正整数> - 每次训练个数 默认值为1

当一个Epoch的样本(也就是全部的训练样本)数量可能太过庞大(对于计算机而言),就须要把它分红多个小块,也就是就是分红多个Batch 来进行训练。batch_size为每批样本的大小。

dataset<下拉框,共包含mnist,cifar10,stl10,svhn> - 训练数据集 默认值为mnist

mnist:该数据集包含60,000个用于训练的示例和10,000个用于测试的示例。这些数字已通过尺寸标准化并位于图像中心,图像是固定大小(28x28像素),其值为0到1。为简单起见,每一个图像都被平展并转换为784(28 * 28)个特征的一维numpy数组。

下载连接:http://yann.lecun.com/exdb/mnist/

cifar10:该数据集共有60000张彩色图像,这些图像是32*32,分为10个类,每类6000张图。这里面有50000张用于训练,构成了5个训练批,每一批10000张图;另外10000用于测试,单独构成一批。测试批的数据里,取自10类中的每一类,每一类随机取1000张。抽剩下的就随机排列组成了训练批。注意一个训练批中的各种图像并不必定数量相同,总的来看训练批,每一类都有5000张图。

下载连接:http://www.cs.toronto.edu/~kriz/cifar-10-binary.tar.gz

stl10:STL-10 是一个图像数据集,包含 10 类物体的图片,每类 1300 张图片,500 张训练,800 张测试,每张图片分辨率为 96x96。除了具备类别标签的图片以外,还有 100000 张无类别信息的图片。

下载连接:https://cs.stanford.edu/~acoates/stl10/

svhn:SVHN(Street View House Number)Dateset 来源于谷歌街景门牌号码,原生的数据集1也就是官网的 Format 1 是一些原始的未经处理的彩色图片,以下图所示(不含有蓝色的边框),下载的数据集含有 PNG 的图像和 digitStruct.mat 的文件,其中包含了边框的位置信息,这个数据集每张图片上有好几个数字,适用于 OCR 相关方向。
下载连接:http://ufldl.stanford.edu/housenumbers/

ifshuffle<勾选框,默认为勾选,在json中为True,不然为False> - 是否打乱数据集 默认为true

platform<下拉框,共包含CPU,GPU> - 运行平台 默认CPU

2. 学习率降低(learning_rate_scheduler)

下拉框,共包括StepLR, MultiStepLR, ExponentialLR, CosineAnnealingLR,ReduceLROnPleateau,None 默认值为None

pytorch提供了几种根据epoch调整学习率的方法。

使用方法:learning_rate_scheduler应在优化器方向传播后进行应用,以下例所示:

>>> scheduler = ...
>>> for epoch in range(100):
>>>     train(...)
>>>     validate(...)
>>>     scheduler.step()

stepLR

在每一个step_size时期,经过gamma下降每一个参数组的学习率。 这种衰减可能与此调度程序外部的学习速率的其余更改同时发生。 当last_epoch = -1时,将初始lr设置为lr。

  • step_size<正整数> - 衰减周期 默认值为50
  • gamma<0-1内实数> - 衰减幅度 默认值0.1

例子:

>>> # Assuming optimizer uses lr = 0.05 for all groups
>>> # lr = 0.05     if epoch < 30
>>> # lr = 0.005    if 30 <= epoch < 60
>>> # lr = 0.0005   if 60 <= epoch < 90
>>> # ...
>>> scheduler = StepLR(optimizer, step_size=30, gamma=0.1)
>>> for epoch in range(100):
>>>     train(...)
>>>     validate(...)
>>>     scheduler.step()

MultiStepLR

当epoch到达milestone后,经过gamma衰减每一个参数组的学习率。这种衰减可能与此调度程序外部的学习速率的其余更改同时发生。 当last_epoch = -1时,将初始lr设置为lr。

  • milestones<非负整数序列,同维度数字之间以英文的“,”分开,例如1,2,3,4,5> - 衰减时间点 默认值为50
  • gamma<0-1内实数> - 衰减幅度 默认值0.1

例子:

>>> # Assuming optimizer uses lr = 0.05 for all groups
>>> # lr = 0.05     if epoch < 30
>>> # lr = 0.005    if 30 <= epoch < 80
>>> # lr = 0.0005   if epoch >= 80
>>> scheduler = MultiStepLR(optimizer, milestones=[30,80], gamma=0.1)
>>> for epoch in range(100):
>>>     train(...)
>>>     validate(...)
>>>     scheduler.step()

ExponentialLR

在每一个epoch以gamma衰减每一个参数组的学习率。 当last_epoch = -1时,将初始lr设置为lr。

  • gamma<0-1内实数> - 衰减幅度 默认值为0.95

CosineAnnealingLR

此函数较为复杂,下图为pytorch文档中对其计算方法的相关说明:

  • T_max<正整数> - 降低周期(变化的半周期)默认值为50
  • eta_min<正数> - 最小学习率 默认值为0

ReduceLROnPleateau

当指标中止改善时,下降学习率。 一旦学习停滞,模型一般会受益于将学习率下降2-10倍。 该调度程序读取一个指标数量,若是在patience时期没有看到改善,则学习速度会下降。

  • factor<0-1内实数> - 调整系数 默认值为0.1
  • patience<正整数> -“耐心 ”,接受几回不变化 默认值为10
  • cooldown<正整数> - “冷却时间”,中止监控一段时间 默认值为10
  • verbose<勾选框> - 打印日志 默认勾选
  • min_lr<0-1内实数> - 学习率下限 默认值为0.0001

例子:

>>> optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
>>> scheduler = ReduceLROnPlateau(optimizer, 'min')
>>> for epoch in range(10):
>>>     train(...)
>>>     val_loss = validate(...)
>>>     # Note that step should be called after validate()
>>>     scheduler.step(val_loss)

3. optimizer:优化器

下拉框,共包含SGD,RMSprop,Adam,Adamax,ASGD 默认值为Adam

优化器是用来计算和更新影响模型训练和输出的网络参数(w和b),从而最小化(或最大化)损失函数Loss。

优化器是求解最优解的过程,能够变相理解为求损失函数极值的问题,因变量为Loss,自变量(优化变量)为w和b,所以须要用到一阶导数(梯度),极值处其方程梯度(一阶导数)为零。有些时候会对优化变量进行约束,包括等式约束和不等式约束,定义了优化变量的可行域,如L1正则化和L2正则化。

SGD

Stochastic Gradient Descent

实现随机梯度降低(可选带动量)。

  • momentum <0-1间实数> - 动量 默认值为0
  • weight_decay <0-1间实数> - L2正则项系数 默认值为0
  • dampening <正数> – 动量衰减 默认值为0
  • nesterov (勾选框,默认为勾选,在json中为True,不然为False) – 使用Nesterov梯度加速 默认值为false

例子:

>>> optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
>>> optimizer.zero_grad()
>>> loss_fn(model(input), target).backward()
>>> optimizer.step()

ASGD

Averaged Stochastic Gradient Descent

实现平均随机梯度降低。

  • lambd <0-1间实数> - 衰减项 默认值为0.0001
  • alpha <0-1间实数> - eta更新幂 默认值为0.75
  • t0 <正整数> – 开始平均的点 默认值为1000000
  • weight_decay<0-1间实数> - L2正则项系数 默认值为0

Adam

实现Adam算法进行梯度降低。

Adam算法介绍:https://arxiv.org/abs/1412.6980

  • beta1<0-1内实数> - 梯度移动平均值的系数 默认值为0.9
  • beta2<0-1内实数> - 梯度平方移动平均值的系数 默认值为0.999
  • eps <0-1内实数>- 分母稳定项 默认值为0.00000001
  • weight_decay<0-1间实数> - L2正则项系数 默认值为0
  • amsgrad(勾选框,默认为勾选,在json中为True,不然为False) - 使用AMSGrad变体 默认值为false

RMSprop

实现RMSprop 算法进行梯度降低。

RMSprop 算法介绍:https://arxiv.org/pdf/1308.0850v5.pdf

  • momentum<0-1间实数>- 动量 默认值为0
  • alpha<0-1间实数> - 平滑常数 默认值为0.99
  • eps<0-1内实数> - 分母稳定项 默认值为0.00000001
  • centered (勾选框,默认为勾选,在json中为True,不然为False)– 梯度经过方差归一化 默认值为flase
  • weight_decay<0-1间实数> - L2正则项系数 默认值为0

Adammax

实现Adamax算法(基于无穷范数的Adam的变体)。

Adamax算法介绍:https://arxiv.org/abs/1412.6980

  • beta1<0-1内实数>- 梯度移动平均值的系数 默认值为0.9
  • beta2<0-1内实数>- 梯度平方移动平均值的系数 默认值为0.999
  • eps<0-1内实数>- 分母稳定项 默认值为0.00000001
  • weight_decay<0-1间实数> - L2正则项系数 默认值为0

4. loss_func:损失函数

下拉框,共包含MSELoss,CrossEntropyLoss,L1Loss,NLLLoss,BCELoss 默认值为MSELoss

损失函数(loss function)是用来估量你模型的预测值f(x)与真实值Y的不一致程度,它是一个非负实值函数,一般使用L(Y, f(x))来表示,损失函数越小,模型的鲁棒性就越好。

MSELoss

均方偏差

pytorch文档中计算函数:

  • reduction (下拉框,共包含none,mean,sum)- 输出的缩减 默认值为mean

例子:

>>> loss = nn.MSELoss()
>>> input = torch.randn(3, 5, requires_grad=True)
>>> target = torch.randn(3, 5)
>>> output = loss(input, target)
>>> output.backward()

CrossEntropyLoss

交叉熵损失

pytorch文档中计算函数:

  • weight (optional, <正数序列>)- 每一个分类损失的权重 默认值为None
  • ignore_index (optional, <整数>)- 忽略的目标 默认值为None
  • reduction (下拉框,共包含none,mean,sum)- 输出的缩减 默认值为mean

例子:

>>> loss = nn.CrossEntropyLoss()
>>> input = torch.randn(3, 5, requires_grad=True)
>>> target = torch.empty(3, dtype=torch.long).random_(5)
>>> output = loss(input, target)
>>> output.backward()

L1Loss

mean absolute error(MAE)

pytorch文档中计算函数:

  • reduction (下拉框,共包含none,mean,sum)- 输出的缩减 默认值为mean

例子:

>>> loss = nn.L1Loss()
>>> input = torch.randn(3, 5, requires_grad=True)
>>> target = torch.randn(3, 5)
>>> output = loss(input, target)
>>> output.backward()

NLLLoss

negative log likelihood loss

pytorch文档中计算函数:

  • weight (optional, <正数序列>)- 每一个分类损失的权重 默认值为None
  • ignore_index (optional, <整数>)- 忽略的目标 默认值为None
  • reduction (下拉框,共包含none,mean,sum)- 输出的缩减 默认值为mean

例子:

>>> m = nn.LogSoftmax(dim=1)
>>> loss = nn.NLLLoss()
>>> # input is of size N x C = 3 x 5
>>> input = torch.randn(3, 5, requires_grad=True)
>>> # each element in target has to have 0 <= value < C
>>> target = torch.tensor([1, 0, 4])
>>> output = loss(m(input), target)
>>> output.backward()
>>>
>>>
>>> # 2D loss example (used, for example, with image inputs)
>>> N, C = 5, 4
>>> loss = nn.NLLLoss()
>>> # input is of size N x C x height x width
>>> data = torch.randn(N, 16, 10, 10)
>>> conv = nn.Conv2d(16, C, (3, 3))
>>> m = nn.LogSoftmax(dim=1)
>>> # each element in target has to have 0 <= value < C
>>> target = torch.empty(N, 8, 8, dtype=torch.long).random_(0, C)
>>> output = loss(m(conv(data)), target)
>>> output.backward()

BCELoss

Binary Cross Entropy between the target and the output

pytorch文档计算函数:

  • weight (optional, <正数序列>)- 每批损失的权重 默认值为None
  • reduction (下拉框,共包含none,mean,sum)- 输出的缩减 默认值为mean

例子:

>>> m = nn.Sigmoid()
>>> loss = nn.BCELoss()
>>> input = torch.randn(3, requires_grad=True)
>>> target = torch.empty(3).random_(2)
>>> output = loss(m(input), target)
>>> output.backward()

说明

本教程部分参考了PyTorch中文手册PyTorch官方文档,若是想要更详细深刻了解的请访问该手册和文档。

若以为官方文档较难读懂,先看如下我的博客:

Pytorch_Part1_简介&张量

Pytorch_Part2_数据模块

Pytorch_Part3_模型模块

Pytorch_Part4_损失函数

Pytorch_Part5_迭代训练

Pytorch_Part6_正则化

Pytorch_Part7_模型使用

相关文章
相关标签/搜索