在使用pytorch搭建神经网络的时候,有两个最常用的包:torch.nn和torch.optim。torch.nn包中主要包含了用来搭建各个层的模块(Modules),比如全连接、二维卷积、池化等;
1.
torch.nn包中还包含了一系列有用的loss函数,这些函数也是在训练神经网络时必不可少的,比如CrossEntropyLoss、MSELoss等;
2.
torch.nn.functional子包中包含了常用的激活函数,如relu、leaky_relu、prelu、sigmoid等。
3.
torch.optim包则主要包含了用来更新参数的优化算法,比如SGD、AdaGrad、RMSProp、 Adam等。
torch.nn 与 torch.nn.functional 的区别
1.从 relu 的多种实现来看 torch.nn 与 torch.nn.functional 的区别与联系:传送门
2.或从.conv2d看torch.nn 与 torch.nn.functional 的区别:从中我们可以发现,nn.Conv2d是一个类,而F.conv2d()是一个函数,而nn.Conv2d的forward()函数实现是用F.conv2d()实现的(在Module类里的__call__实现了forward()函数的调用,所以当实例化nn.Conv2d类时,forward()函数也被执行了,详细可阅读torch源码),所以两者功能并无区别,那么为什么要有这样的两种实现方式同时存在呢?
原因其实在于,为了兼顾灵活性和便利性。
在建图过程中,往往有两种层,一种如全连接层,卷积层等,当中有Variable,另一种如Pooling层,Relu层等,当中没有Variable。
如果所有的层都用nn.functional来定义,那么所有的Variable,如weights,bias等,都需要用户来手动定义,非常不方便。
而如果所有的层都换成nn来定义,那么即便是简单的计算都需要建类来做,而这些可以用更为简单的函数来代替的。
所以在定义网络的时候,如果层内有Variable,那么用nn定义,反之,则用nn.functional定义。(转载:nn.functional和nn区别)
log_softmax和softmax的区别:
我的理解是这样的:理论上对于单标签多分类问题,直接经过softmax求出概率分布,然后把这个概率分布用crossentropy做一个似然估计误差。但是softmax求出来的概率分布,每一个概率都是(0,1)的,这就会导致有些概率过小,导致下溢。 考虑到这个概率分布总归是要经过crossentropy的,而crossentropy的计算是把概率分布外面套一个-log 来似然,那么直接在计算概率分布的时候加上log,把概率从(0,1)变为(-∞,0),这样就防止中间会有下溢出。 所以log_softmax说白了就是将本来应该由crossentropy做的套log的工作提到预测概率分布来,跳过了中间的存储步骤,防止中间数值会有下溢出,使得数据更加稳定。 正是由于把log这一步从计算误差提到前面,所以用log_softmax之后,下游的计算误差的function就应该变成NLLLoss(它没有套log这一步,直接将输入取反,然后计算和label的乘积求和平均) 详细见softmax和log_softmax的区别、CrossEntropyLoss() 与 NLLLoss() 的区别、log似然代价函数
其中log_softmax的dim问题可参考:dim问题,跑跑代码很容易理解的
torch.utils.data.DataLoader可见:传送门1,传送门2;主要用来将自定义的数据读取接口的输出或者PyTorch已有的数据读取接口的输入按照batch size封装成Tensor,后续只需要再包装成Variable即可作为模型的输入,因此该接口有点承上启下的作用,比较重要。主要包含DataLoader和DataLoaderIter两个类。
SGD+Momentum:SGD+Momentum
eg:
# momentum 动量加速,在SGD函数里指定momentum的值即可
opt_Momentum = torch.optim.SGD(net_Momentum.parameters(), lr=LR, momentum=0.8)
nn.Conv2d简单说明
卷积操作输出的形状计算公式是这样的:
output_shape = (image_shape-filter_shape+2*padding)/stride + 1
1.1首先我们定义一个基于CNN的简单神经网络
这个torchvision是独立于pytorch的关于图#像操作的一些方便工具库。它包含几个数据包(包括mnist详见torchvision )
import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms #
print("PyTorch Version: ",torch.__version__)
PyTorch Version: 1.0.0
首先我们定义一个基于ConvNet的简单神经网络
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 20, 5, 1) #28*28 ->(28+1-5输出的计算公式,见上)=24*24
self.conv2 = nn.Conv2d(20, 50, 5, 1)#20 *20
self.fc1 = nn.Linear(4*4*50, 500)
self.fc2 = nn.Linear(500, 10)
def forward(self, x):
x = F.relu(self.conv1(x))#20*24*24
x = F.max_pool2d(x, 2, 2)#12*12
x = F.relu(self.conv2(x))#8*8
x = F.max_pool2d(x, 2, 2)#4*4
x = x.view(-1, 4*4*50)
x = F.relu(self.fc1(x))
x = self.fc2(x)
return F.log_softmax(x, dim=1)
mnist_data=datasets.MNIST("E:/path/pytorch_download",train=True,download=False,
#transforms.Compose是把数据集变为一个tensor
transform=transforms.Compose(
[
transforms.ToTensor(),
]
))
#print(mnist_data[2][0].shape) #mnist_data[x]是图片,mnist_data[x][1]是类别
data=[d[0].data.cpu().numpy() for d in mnist_data]#把图片转为numpy
#print(np.mean(data))
#print(np.std(data))
#下面两个函数,等会会调用
def train(model,device,train_loader,optimizer,epoch):
model.train()
#data是图片,target是图片对应的标签
for idx,(data,target) in enumerate(train_loader):
data,target=data.to(device),target.to(device)
pred=model(data) #batch_size=10,pred就是相当于图片经过模型得到的一个预测值(向量(10个类的概率))
loss=F.nll_loss(pred,target)
#SGD
optimizer.zero_grad()
loss.backward()
optimizer.step()
if idx% 100==0:
print("Train Epoch:{},iteration:{},loss:{}".format(
epoch,idx,loss.item()))
def test(model,device,test_loader):
model.eval()
total_loss=0.
correct=0.
with torch.no_grad():
#data是图片,target是图片对应的标签
for idx,(data,target) in enumerate(test_loader):
data,target=data.to(device),target.to(device)
output = model(data)
total_loss+=F.nll_loss(output,target,reduction="sum").item()
pred = output.argmax(dim=1) # batch_size=10,pred就是相当于图片经过模型得到的一个预测值(向量(10个类的概率))
correct+=pred.eq(target.view_as(pred)).sum().item()
#测试不用sgd
total_loss/=len(test_loader.dataset)#这里因为上面sum了,所以要除以所以
acc=correct/len(test_loader.dataset)*100.
print("Test loss:{},Accuracy:{}".format(total_loss,acc))
device=torch.device("cuda" if torch.cuda.is_available() else "cpu")
batch_size=32
train_loader=torch.utils.data.DataLoader(
datasets.MNIST("E:/path/pytorch_download",train=True,download=False,
#transforms.Compose是把数据集变为一个tensor
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,),(0.3081,))])), #图片标准化
batch_size=batch_size,shuffle=True,
num_workers=0,pin_memory=True
)
test_loader=torch.utils.data.DataLoader(
datasets.MNIST("E:/path/pytorch_download",train=False,download=False,
#transforms.Compose是把数据集变为一个tensor
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,),(0.3081,))])), #图片标准化
batch_size=batch_size,shuffle=True,
num_workers=0,pin_memory=True
)
lr=0.01
momentum=0.5
model=Net().to(device)
optimizer=torch.optim.SGD(model.parameters(),lr=lr,momentum=momentum)
num_epochs=2
for epoch in range(num_epochs):
train(model,device,train_loader,optimizer,epoch)
test(model,device,test_loader)
save_model = True
if (save_model):
torch.save(model.state_dict(),"mnist_cnn.pt")
Batch Normalization:可见:莫凡Normalization
model.train 和 model.eval:传送门
NLLLoss:Softmax后的数值都在0~1之间,所以ln之后值域是负无穷到0。
NLLLoss的结果就是把上面的输出与Label对应的那个值拿出来,再去掉负号,再求均值。
假设我们现在Target是[0,2,1](第一张图片是猫,第二张是猪,第三张是狗)。第一行取第0个元素,第二行取第2个,第三行取第1个,去掉负号,结果是:[0.4155,1.0945,1.5285]。再求个均值,结果是:
转载:Pytorch详解NLLLoss和CrossEntropyLoss、、PyTorch-损失函数-NLLLoss
view_as (转载:view_as)
返回被视作与给定的tensor相同大小的原tensor。 等效于:
self.view(tensor.size())
具体用法为:
代码
a = torch.Tensor(2, 4)
b = a.view_as(torch.Tensor(4, 2))
print (b)
输出
tensor([[1.3712e-14, 6.4069e+02],
[4.3066e+21, 1.1824e+22],
[4.3066e+21, 6.3828e+28],
[3.8016e-39, 0.0000e+00]])