神经网络

神经网络

pytorch运行一个网络。epoch 次数太多了,就中断了修改参数重新跑,然后就报错了out of memory

pytorchtanpytorch 回复了问题 • 2 人关注 • 2 个回复 • 3742 次浏览 • 2018-10-16 11:24 • 来自相关话题

关于pytorch中forward函数的写法?

pytorch16块的黄鹤楼 回复了问题 • 2 人关注 • 1 个回复 • 5657 次浏览 • 2018-09-26 11:00 • 来自相关话题

如何用pytorch拟合sin()函数生成的点

回复

pytorchrtfsc 发起了问题 • 1 人关注 • 0 个回复 • 1927 次浏览 • 2018-06-04 16:31 • 来自相关话题

Pytorch中训练神经网络

pytorchwednesday_duo 回复了问题 • 2 人关注 • 1 个回复 • 3243 次浏览 • 2018-05-04 18:17 • 来自相关话题

我现有3万张图片,如何能够把他们以numpy的格式保存起来?

CUDAwoniu0755 回复了问题 • 3 人关注 • 2 个回复 • 1925 次浏览 • 2018-04-25 16:55 • 来自相关话题

pycharm pythorch

回复

pytorchchuwill 发起了问题 • 1 人关注 • 0 个回复 • 1431 次浏览 • 2018-04-16 20:52 • 来自相关话题

pytorch如何将Variable数据转化为Tensor数据

回复

pytorchthc222 回复了问题 • 1 人关注 • 1 个回复 • 2541 次浏览 • 2018-04-07 23:46 • 来自相关话题

LSTM在哪里?

pytorch想念成都的美食 回复了问题 • 2 人关注 • 1 个回复 • 1863 次浏览 • 2018-01-30 02:09 • 来自相关话题

pytorch如何在两个网络之间共享权重?

pytorch想念成都的美食 回复了问题 • 2 人关注 • 1 个回复 • 5955 次浏览 • 2018-01-30 02:02 • 来自相关话题

PYTORCH 使用CUDA

pytorchxus 回复了问题 • 2 人关注 • 1 个回复 • 1989 次浏览 • 2018-01-25 23:26 • 来自相关话题

pytorch运行一个网络。epoch 次数太多了,就中断了修改参数重新跑,然后就报错了out of memory

回复

pytorchtanpytorch 回复了问题 • 2 人关注 • 2 个回复 • 3742 次浏览 • 2018-10-16 11:24 • 来自相关话题

Pytorch中训练神经网络

回复

pytorchwednesday_duo 回复了问题 • 2 人关注 • 1 个回复 • 3243 次浏览 • 2018-05-04 18:17 • 来自相关话题

ImportError: dlopen: cannot load any more object with static TLS

回复

pytorch紫林落雪 发起了问题 • 1 人关注 • 0 个回复 • 2370 次浏览 • 2018-01-16 15:48 • 来自相关话题

[pytorch快速入门教程]神经网络,构造一个小型CNN

pytorchwda 发表了文章 • 0 个评论 • 1163 次浏览 • 2017-05-31 22:22 • 来自相关话题

神经网络可以使用torch.nn包来构建。
现在你大致了解了autograd,nn依赖于autograd来定义模型并进行求导。一个nn.Module包含多个神经网络层,以及一个forward(input)方法来返回output。

例如,看看以下这个分类数字图像的网络:






它是一个简单的前馈网络。它将输入逐步地喂给多个层,然后给出输出。

一个典型的神经网络训练过程如下:
定义一个拥有可学习参数(或权重)的神经网络在输入数据上进行迭代在网络中处理数据计算损失(输出离分类正确有多远)梯度反向传播给网络的参数更新网络的权重,通常使用一个简单的更新规则:weight = weight + learning_rate * gradient

定义网络

import torch
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F

class Net(nn.Module):

def __init__(self):
super(Net, self).__init__()
# 1 图像输入通道, 6 输出通道, 5x5 正方形卷积核
self.conv1 = nn.Conv2d(1, 6, 5)
self.conv2 = nn.Conv2d(6, 16, 5)
# an affine operation: y = Wx + b
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)

def forward(self, x):
# 使用 (2, 2) 窗口最大池化
x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
# If the size is a square you can only specify a single number
x = F.max_pool2d(F.relu(self.conv2(x)), 2)
x = x.view(-1, self.num_flat_features(x))
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x

def num_flat_features(self, x):
size = x.size()[1:] # 所有维度,除了批尺寸
num_features = 1
for s in size:
num_features *= s
return num_features

net = Net()
print(net)输出:Net (
(conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
(conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
(fc1): Linear (400 -> 120)
(fc2): Linear (120 -> 84)
(fc3): Linear (84 -> 10)
)
你只需要定义forward函数,backward函数(用来计算梯度)是使用autograd自动为你定义的。你可以在forward中使用任意的Tensor运算操作。

模型中可学习的参数是通过net.parameters()返回的:params = list(net.parameters())
print(len(params))
print(params[0].size()) # conv1's .weight输出:10
torch.Size([6, 1, 5, 5])forward的输入是一个autograd.Variable ,输出亦然。input = Variable(torch.randn(1, 1, 32, 32))
out = net(input)
print(out)输出:Variable containing:
0.0455 -0.0445 0.0064 -0.0310 0.0945 -0.0362 -0.1971 0.0555 0.0943 0.1016
[torch.FloatTensor of size 1x10]将梯度缓冲区置0,并使用随机的梯度进行反向传播:net.zero_grad()
out.backward(torch.randn(1, 10))

注意:
torch.nn仅支持mini-batch。整个的torch.nn包仅支持小批量的数据,而不是一个单独的样本。
例如,nn.Conv2d应传入一个4D的Tensor,维度为nSamples x nChannels x Height x Width。
如果你有一个单独的样本,使用input.unsqueeze(0)来添加一个伪批维度。
在继续之前,我们先回顾一下迄今为止的所有课程。


回顾总结:
torch.Tensor 一个多维数组autograd.Variable 包装一个Tensor并且记录应用在其上的历史运算操作。拥有与Tensor相同的API,添加了一些像backward()的操作。还包括相关tensor的梯度。nn.Module 神经网络模块。封装参数的方便方式,带有将它们转移到GPU、导出、载入等的帮助函数。nn.Parameter 一种Variable,当给Module赋值时自动注册一个参数。autograd.Function 实现一个autograd 操作的 forward 和 backward 定义。每一个Variable操作,创建至少一个Function节点,来连接那些创建Variable的函数,并且记录其历史。
在这里,我们涵盖了:
定义神经网络处理输入并调用backward
还剩下:
计算损失更新网络权重

损失函数


一个损失函数以一个(output, target)对为输入,然后计算一个值用以估计输出结果离目标结果多远。
存在多种的损失函数。一个简单的损失函数:nn.MSELoss,它计算输出与目标的均方误差。

例如:output = net(input)
target = Variable(torch.arange(1, 11)) # a dummy target, for example
criterion = nn.MSELoss()

loss = criterion(output, target)
print(loss)输出:Variable containing:
38.3005
[torch.FloatTensor of size 1]现在,如果你在反方向跟随loss,使用它的.creator属性,你会看到一个如下所示的计算图:input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d
-> view -> linear -> relu -> linear -> relu -> linear
-> MSELoss
-> loss因此,当我们调用loss.backward()时,损失对应的整个图都被求导,并且图中所有的变量都会带有累积了梯度的.grad属性。print(loss.creator) # MSELoss
print(loss.creator.previous_functions[0][0]) # linear
print(loss.creator.previous_functions[0][0].previous_functions[0][0]) # ReLU
输出:<torch.nn._functions.thnn.auto.MSELoss object at 0x10e0bdd68>
<torch.nn._functions.linear.Linear object at 0x10e0bdba8>
<torch.nn._functions.thnn.auto.Threshold object at 0x10e0bdac8>
反向传播

要进行反向传播,我们只需要调用loss.backward()。你需要清除现有的梯度,否则梯度将累积到现有梯度。

现在我们将调用loss.backward(),并看看conv1在backward之前和之后的梯度变化。net.zero_grad() # zeroes the gradient buffers of all parameters

print('conv1.bias.grad before backward')
print(net.conv1.bias.grad)

loss.backward()

print('conv1.bias.grad after backward')
print(net.conv1.bias.grad)
输出:conv1.bias.grad before backward
Variable containing:
0
0
0
0
0
0
[torch.FloatTensor of size 6]

conv1.bias.grad after backward
Variable containing:
0.1392
-0.1155
0.0247
0.1121
-0.0559
0.0363
[torch.FloatTensor of size 6]
现在我们知道怎么使用损失函数了。

延伸阅读

神经网络包包含构建深度神经网络的多个模块和损失函数。一个完整的文档列表在这里

仅剩的一个要学习的东西:
更新网络权重

更新权重


实践中最简单的更新规则是随机梯度下降(SGD):weight = weight - learning_rate * gradient
我们可以使用简单的Python代码实现:learning_rate = 0.01
for f in net.parameters():
f.data.sub_(f.grad.data * learning_rate)
然而,当您使用神经网络时,您希望使用各种不同的更新规则,例如SGD,Nesterov-SGD,Adam,RMSProp等等。为了实现这一点,我们构建一个小的包:torch.optim,来实现所有的方法。使用非常简单:import torch.optim as optim

# create your optimizer
optimizer = optim.SGD(net.parameters(), lr=0.01)

# in your training loop:
optimizer.zero_grad() # zero the gradient buffers
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step() # Does the update 查看全部
神经网络可以使用torch.nn包来构建。
现在你大致了解了autograd,nn依赖于autograd来定义模型并进行求导。一个nn.Module包含多个神经网络层,以及一个forward(input)方法来返回output。

例如,看看以下这个分类数字图像的网络:

mnist.png


它是一个简单的前馈网络。它将输入逐步地喂给多个层,然后给出输出。

一个典型的神经网络训练过程如下:
  • 定义一个拥有可学习参数(或权重)的神经网络
  • 在输入数据上进行迭代
  • 在网络中处理数据
  • 计算损失(输出离分类正确有多远)
  • 梯度反向传播给网络的参数
  • 更新网络的权重,通常使用一个简单的更新规则:weight = weight + learning_rate * gradient


定义网络


import torch
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as F

class Net(nn.Module):

def __init__(self):
super(Net, self).__init__()
# 1 图像输入通道, 6 输出通道, 5x5 正方形卷积核
self.conv1 = nn.Conv2d(1, 6, 5)
self.conv2 = nn.Conv2d(6, 16, 5)
# an affine operation: y = Wx + b
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)

def forward(self, x):
# 使用 (2, 2) 窗口最大池化
x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
# If the size is a square you can only specify a single number
x = F.max_pool2d(F.relu(self.conv2(x)), 2)
x = x.view(-1, self.num_flat_features(x))
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x

def num_flat_features(self, x):
size = x.size()[1:] # 所有维度,除了批尺寸
num_features = 1
for s in size:
num_features *= s
return num_features

net = Net()
print(net)
输出:
Net (
(conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
(conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
(fc1): Linear (400 -> 120)
(fc2): Linear (120 -> 84)
(fc3): Linear (84 -> 10)
)

你只需要定义forward函数,backward函数(用来计算梯度)是使用autograd自动为你定义的。你可以在forward中使用任意的Tensor运算操作。

模型中可学习的参数是通过net.parameters()返回的:
params = list(net.parameters())
print(len(params))
print(params[0].size()) # conv1's .weight
输出:
10
torch.Size([6, 1, 5, 5])
forward的输入是一个autograd.Variable ,输出亦然。
input = Variable(torch.randn(1, 1, 32, 32))
out = net(input)
print(out)
输出:
Variable containing:
0.0455 -0.0445 0.0064 -0.0310 0.0945 -0.0362 -0.1971 0.0555 0.0943 0.1016
[torch.FloatTensor of size 1x10]
将梯度缓冲区置0,并使用随机的梯度进行反向传播:
net.zero_grad()
out.backward(torch.randn(1, 10))


注意:
torch.nn仅支持mini-batch。整个的torch.nn包仅支持小批量的数据,而不是一个单独的样本。
例如,nn.Conv2d应传入一个4D的Tensor,维度为nSamples x nChannels x Height x Width。
如果你有一个单独的样本,使用input.unsqueeze(0)来添加一个伪批维度。
在继续之前,我们先回顾一下迄今为止的所有课程。



回顾总结:
  • torch.Tensor 一个多维数组
  • autograd.Variable 包装一个Tensor并且记录应用在其上的历史运算操作。拥有与Tensor相同的API,添加了一些像backward()的操作。还包括相关tensor的梯度。
  • nn.Module 神经网络模块。封装参数的方便方式,带有将它们转移到GPU、导出、载入等的帮助函数。
  • nn.Parameter 一种Variable,当给Module赋值时自动注册一个参数。
  • autograd.Function 实现一个autograd 操作的 forward 和 backward 定义。每一个Variable操作,创建至少一个Function节点,来连接那些创建Variable的函数,并且记录其历史。

在这里,我们涵盖了:
  • 定义神经网络
  • 处理输入并调用backward

还剩下:
  • 计算损失
  • 更新网络权重


损失函数



一个损失函数以一个(output, target)对为输入,然后计算一个值用以估计输出结果离目标结果多远。
存在多种的损失函数。一个简单的损失函数:nn.MSELoss,它计算输出与目标的均方误差。

例如:
output = net(input)
target = Variable(torch.arange(1, 11)) # a dummy target, for example
criterion = nn.MSELoss()

loss = criterion(output, target)
print(loss)
输出:
Variable containing:
38.3005
[torch.FloatTensor of size 1]
现在,如果你在反方向跟随loss,使用它的.creator属性,你会看到一个如下所示的计算图:
input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d
-> view -> linear -> relu -> linear -> relu -> linear
-> MSELoss
-> loss
因此,当我们调用loss.backward()时,损失对应的整个图都被求导,并且图中所有的变量都会带有累积了梯度的.grad属性。
print(loss.creator)  # MSELoss
print(loss.creator.previous_functions[0][0]) # linear
print(loss.creator.previous_functions[0][0].previous_functions[0][0]) # ReLU

输出:
<torch.nn._functions.thnn.auto.MSELoss object at 0x10e0bdd68>
<torch.nn._functions.linear.Linear object at 0x10e0bdba8>
<torch.nn._functions.thnn.auto.Threshold object at 0x10e0bdac8>

反向传播

要进行反向传播,我们只需要调用loss.backward()。你需要清除现有的梯度,否则梯度将累积到现有梯度。

现在我们将调用loss.backward(),并看看conv1在backward之前和之后的梯度变化。
net.zero_grad()   # zeroes the gradient buffers of all parameters

print('conv1.bias.grad before backward')
print(net.conv1.bias.grad)

loss.backward()

print('conv1.bias.grad after backward')
print(net.conv1.bias.grad)

输出:
conv1.bias.grad before backward
Variable containing:
0
0
0
0
0
0
[torch.FloatTensor of size 6]

conv1.bias.grad after backward
Variable containing:
0.1392
-0.1155
0.0247
0.1121
-0.0559
0.0363
[torch.FloatTensor of size 6]

现在我们知道怎么使用损失函数了。

延伸阅读

神经网络包包含构建深度神经网络的多个模块和损失函数。一个完整的文档列表在这里

仅剩的一个要学习的东西:
  • 更新网络权重


更新权重



实践中最简单的更新规则是随机梯度下降(SGD):
weight = weight - learning_rate * gradient

我们可以使用简单的Python代码实现:
learning_rate = 0.01
for f in net.parameters():
f.data.sub_(f.grad.data * learning_rate)

然而,当您使用神经网络时,您希望使用各种不同的更新规则,例如SGD,Nesterov-SGD,Adam,RMSProp等等。为了实现这一点,我们构建一个小的包:torch.optim,来实现所有的方法。使用非常简单:
import torch.optim as optim

# create your optimizer
optimizer = optim.SGD(net.parameters(), lr=0.01)

# in your training loop:
optimizer.zero_grad() # zero the gradient buffers
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step() # Does the update