VisualPytorch发布域名+双服务器以下:
http://nag.visualpytorch.top/static/ (对应114.115.148.27)
http://visualpytorch.top/static/ (对应39.97.209.22)html
首先打开网址,进入网站的首页。网站有游客游览模式和用户登陆模式,建议先注册登陆一个帐号,也是十分简便的啦,由于这样可使用更多的功能。python
页面头部有三个选项,分别为VisualPytorch, 帮助和联系咱们,VisualPytorch就是主页面,能够进行模型的搭建,帮助页面是本网站的简单教程以及相关知识的讲解,在联系咱们界面,能够给咱们反馈你在使用过程当中的遇到的问题,帮助咱们进步呀。git
在VisualPytorch界面左侧有可选择的网络层,这些层就是用来搭建神经网络模型的基本组件,在网络层的下面还有训练参数配置,主要用于肯定模型的全局训练参数。下面给你们简单展现一下如何拖拽和删除这些组件框,以及组件框参数的位置。github
在VisualPytorch界面左上角有生成代码按钮,当你搭建好本身的神经网络模型以后,就能够点击这个按钮,而后会跳转到代码页面,你也就能够看到生成的代码啦,而后再点击下载代码,就能够把代码下载到本地,畅快的玩耍一番啦。算法
考虑到也许后续还要用本身搭建过的模型,因此咱们实现了保存模型这一功能(贴心的团队,有木有),当你搭建好一个模型以后,能够直接选择保存,而后模型就会保存到你的帐号啦,下次你登陆还能够查看本身以前的模型。json
咱们的网站旨在利用清晰的可视化模型来帮助热爱deep learning的你快速搭建想搭建的模型。canvas
目前支持的神经网络层有:reshape层,全链接层,一维卷积层,二维卷积层; 这些层及其涉及的参数的具体含义都与pytorch官方文档里一致。数组
模型的搭建经过将左侧的各种层模块拖入右侧画布并连线来完成。服务器
main.py里的代码主要是涉及全局的参数以及训练部分,目前该部分还有待完善。网络
model.py里则主要是搭建的模型代码,整个模型咱们封装成了一个类,类名是 NET。
注册用户拥有保存本身搭建的模型并管理的权限,用户能够经过点击页面上显示的用户名,弹出 模型查看 和 登出 选项,点击模型查看便可进入模型管理的页面,该页面会显示用户曾搭建并保存的全部模型,每一个模型都有对应的 查看 和 删除 按钮。点击查看便可进入模型搭建的页面并恢复用户曾保存的模型,用户能够对该模型进行从新编辑。点击删除便可删除相应的模型。
VGG卷积神经网络是牛津大学在2014年提出来的模型,它在图像分类和目标检测任务中都表现出很是好的结果。同时,VGG16模型的权重由ImageNet训练而来。
AlexNet是2012年ImageNet项目的大规模视觉识别挑战中的胜出者,该项目一种巧妙的手法打破了旧观念,开创了计算机视觉的新局面。
一种新型的深度网络结构,它能够加强模型在感觉野内对局部区域的辨别能力。
返回一个有相同数据但大小不一样的tenser。返回的tenser必须有与原tenser相同的数据和相同数目的元素,但能够有不一样的大小。一个tenser必须是连续的contiguous()
才能被查看。
简单来看,view的参数就比如一个矩阵的行和列的值,当为一个数n的时候,则将数据大小变为1xn。
参数:
class torch.nn.Linear(in_features, out_features, bias=True)
对输入数据作线性变换:y*=*Ax+b
参数:
形状:
变量:
例子:
>>> m = nn.Linear(20, 30) >>> input = autograd.Variable(torch.randn(128, 20)) >>> output = m(input) >>> print(output.size())
该层不须要参数,做为几个层之间的衔接,须要注意的是,该函数的输入能够为多个向量。
torch.cat(inputs, dimension=0) → Tensor
在给定维度上对输入的张量序列seq
进行链接操做。
torch.cat()
能够看作 torch.split()
和 torch.chunk()
的反操做。 cat()
函数能够经过下面例子更好的理解。
参数:
例子:
>>> 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]
class torch.nn.Softmax(dim=None)
将Softmax函数应用于n维输入Tensor,对它们进行从新缩放,使得n维输出Tensor的元素位于[0,1]范围内而且总和为1。
函数表达式:
Softmax(xi)=exi∑jexjSoftmax(xi)=exi∑jexj
返回:
参数:
例子:
>>> m = nn.Softmax() >>> input = torch.randn(2, 3) >>> output = m(input)
torch.nn.Dropout(p=0.5, inplace=False)
在训练期间,使用伯努利分布的样本以几率p将输入张量的某些元素随机置零。 在每次前向传播时,每一个通道将独立清零。事实证实,这是一种有效的技术,可用于规范化和防止神经元的协同适应。
例子:
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]])
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)的计算方式:
layer_type<下拉框二选一,conv/conv_transpose> - 分别表示卷积与反卷积 默认值为conv
conv和conv_transpose参数相同
形状:
变量:
tensor
) - 卷积的权重,大小是(out_channels
, in_channels
, kernel_size
)tensor
) - 卷积的偏置系数,大小是(out_channel
)例子:
>>> m = nn.Conv1d(16, 33, 3, stride=2) >>> input = autograd.Variable(torch.randn(20, 16, 50)) >>> output = m(input)
在神经网络中,池化函数(Pooling Function)通常将上一层卷积函数的结果做为本身的输入。通过卷积层提取过特征以后,咱们获得的通道数可能会增大不少,也就是说数据的维度会变得更高,这个时候就须要对数据进行池化操做,也就是降维操做。
池化操做是用每一个矩阵的最大值或是平均值来表明这个矩阵,从而实现元素个数的减小,而且最大值和平均值操做可使得特征提取具备“平移不变性”。
layer_type<下拉框三选一,选项包括max_pool, avg_pool, max_unpool > 默认值为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
这些参数。
参数:
例子:
>>> # 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)
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
这些参数。
参数:
例子:
>>> # 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]
torch.nn.MaxUnpool1d(kernel_size, stride=None, padding=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.]]])
激活函数做用在人工神经网络上,负责将神经元的输入映射到输出端。增长了神经网络的非线性,使得神经网络能够任意逼近任意非线性函数,从而使神经网络应用到众多的非线性模型中。
layer_type<下拉框,包括relu/sigmoid/tanh/leaky relu/PRelu/RRelu> 默认值为relu
函数表达式:
\(relu(x)=max(0,x)\)
对应图像:
函数表达式:
\(LeakyRelu(x)=max(x,0) + negative\_slope*min(0,x)\)
参数:
对应图像:
函数表达式:
\(sigmoid(x)=\frac{1}{1+e^{-x}}\)
函数图像:
函数表达式:
\(tanh(x)=\frac{e^x-e^{-x}}{e^x+e^-x}\)
函数图像:
torch.nn.PReLU(num_parameters=1, init=0.25)
函数表达式:PReLU(x)=max(0,x)+a∗min(0,x)
函数图像:
相似leaky relu, 可是负数部分斜率可学习
参数:
torch.nn.RReLU(lower=0.125, upper=0.3333333333333333, inplace=False)
函数表达式:
相似leaky relu, 可是负数部分斜率为随机均匀分布
参数:
torch.nn.RNN(*args, **kwargs)
RNN(Recurrent Neural Networks,循环神经网络)不只会学习当前时刻的信息,也会依赖以前的序列信息。因为其特殊的网络模型结构解决了信息保存的问题。因此RNN对处理时间序列和语言文本序列问题有独特的优点。递归神经网络都具备一连串重复神经网络模块的形式。在标准的RNNs中,这种重复模块有一种很是简单的结构。
计算公式:
具体参数含义:ht是隐藏层在时间t时的状态,xt是时间t时的输入,h(t-1)是隐藏层在t-1时的状态。若是非线性激活函数为relu,那么tanh将用ReLU代替。
参数:
torch.nn.LSTM(*args, **kwargs)
Long Short Term Memory networks(如下简称LSTMs),一种特殊的RNN网络,该网络设计出来是为了解决长依赖问题。该网络由 [Hochreiter & Schmidhuber (1997)引入,并有许多人对其进行了改进和普及。他们的工做被用来解决了各类各样的问题,直到目前还被普遍应用。
LSTM的计算公式较为复杂,下图截取了pytorch官方文档中的部份内容:
参数:
layer_type<下拉框,选项包括batch_norm/group_norm/instance_norm> 默认值为batch_norm
咱们在对数据训练以前会对数据集进行归一化,归一化的目的归一化的目的就是使得预处理的数据被限定在必定的范围内(好比[0,1]或者[-1,1]),从而消除奇异样本数据致使的不良影响,同时便于加快训练速度。
torch.nn.BatchNorm1d(num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
计算公式:
参数:
例子:
>>> m = nn.BatchNorm1d(100) >>> # Without Learnable Parameters >>> m = nn.BatchNorm1d(100, affine=False) >>> input = torch.randn(20, 100) >>> output = m(input)
torch.nn.GroupNorm(num_groups, num_channels, eps=1e-05, affine=True)
计算公式:
参数:
例子:
>>> # 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)
torch.nn.InstanceNorm1d(num_features, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)
计算公式:
参数:
例子:
>>> # 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)
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
下拉框,共包括StepLR, MultiStepLR, ExponentialLR, CosineAnnealingLR,ReduceLROnPleateau,None 默认值为None
pytorch提供了几种根据epoch调整学习率的方法。
使用方法:learning_rate_scheduler应在优化器方向传播后进行应用,以下例所示:
>>> scheduler = ... >>> for epoch in range(100): >>> train(...) >>> validate(...) >>> scheduler.step()
在每一个step_size时期,经过gamma下降每一个参数组的学习率。 这种衰减可能与此调度程序外部的学习速率的其余更改同时发生。 当last_epoch = -1时,将初始lr设置为lr。
例子:
>>> # 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()
当epoch到达milestone后,经过gamma衰减每一个参数组的学习率。这种衰减可能与此调度程序外部的学习速率的其余更改同时发生。 当last_epoch = -1时,将初始lr设置为lr。
例子:
>>> # 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()
在每一个epoch以gamma衰减每一个参数组的学习率。 当last_epoch = -1时,将初始lr设置为lr。
此函数较为复杂,下图为pytorch文档中对其计算方法的相关说明:
当指标中止改善时,下降学习率。 一旦学习停滞,模型一般会受益于将学习率下降2-10倍。 该调度程序读取一个指标数量,若是在patience时期没有看到改善,则学习速度会下降。
例子:
>>> 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)
下拉框,共包含SGD,RMSprop,Adam,Adamax,ASGD 默认值为Adam
优化器是用来计算和更新影响模型训练和输出的网络参数(w和b),从而最小化(或最大化)损失函数Loss。
优化器是求解最优解的过程,能够变相理解为求损失函数极值的问题,因变量为Loss,自变量(优化变量)为w和b,所以须要用到一阶导数(梯度),极值处其方程梯度(一阶导数)为零。有些时候会对优化变量进行约束,包括等式约束和不等式约束,定义了优化变量的可行域,如L1正则化和L2正则化。
Stochastic Gradient Descent
实现随机梯度降低(可选带动量)。
例子:
>>> optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9) >>> optimizer.zero_grad() >>> loss_fn(model(input), target).backward() >>> optimizer.step()
Averaged Stochastic Gradient Descent
实现平均随机梯度降低。
实现Adam算法进行梯度降低。
Adam算法介绍:https://arxiv.org/abs/1412.6980
实现RMSprop 算法进行梯度降低。
RMSprop 算法介绍:https://arxiv.org/pdf/1308.0850v5.pdf
实现Adamax算法(基于无穷范数的Adam的变体)。
Adamax算法介绍:https://arxiv.org/abs/1412.6980
下拉框,共包含MSELoss,CrossEntropyLoss,L1Loss,NLLLoss,BCELoss 默认值为MSELoss
损失函数(loss function)是用来估量你模型的预测值f(x)与真实值Y的不一致程度,它是一个非负实值函数,一般使用L(Y, f(x))来表示,损失函数越小,模型的鲁棒性就越好。
均方偏差
pytorch文档中计算函数:
例子:
>>> loss = nn.MSELoss() >>> input = torch.randn(3, 5, requires_grad=True) >>> target = torch.randn(3, 5) >>> output = loss(input, target) >>> output.backward()
交叉熵损失
pytorch文档中计算函数:
例子:
>>> 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()
mean absolute error(MAE)
pytorch文档中计算函数:
例子:
>>> loss = nn.L1Loss() >>> input = torch.randn(3, 5, requires_grad=True) >>> target = torch.randn(3, 5) >>> output = loss(input, target) >>> output.backward()
negative log likelihood loss
pytorch文档中计算函数:
例子:
>>> 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()
Binary Cross Entropy between the target and the output
pytorch文档计算函数:
例子:
>>> 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官方文档,若是想要更详细深刻了解的请访问该手册和文档。
若以为官方文档较难读懂,先看如下我的博客: