Pytorch 3.4.5 Softmax 框架实现

Softmax 框架实现

step1.import the packages

import torch
from torch import nn
from d2l import torch as d2l

step2.loading dataset and set batch_size

batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

step3.define ours' module

# PyTorch不会隐式地调整输入的形状。因此，
# 我们在线性层前定义了展平层（flatten），来调整网络输入的形状
net = nn.Sequential(nn.Flatten() , nn.Linear(in_features=784 , out_features= 10)) 

def init_weights(m): 
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, std=0.01)
net.apply(init_weights);

step4.define other's function

"""这里的Corss Entropy Loss Function 和我们之前实现有些许不同 ,这里的原数据每一个值都减去了最大值之后在进行Softmax操作"""
# 损失函数
loss = nn.CrossEntropyLoss() 
# 优化算法 
trainer = torch.optim.SGD(net.parameters(), lr=0.1) 

step5.trining our module

# 训练 
num_epochs = 10
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)

章节答疑

1. torch.nn.Sequential()和torch.nn.Flatten()

# 展平化 torch.nn.Flatten(x)  & torch.nn.flatten(x) 
import torch 
x=torch.randn(2,4,2) 
torch.flatten(x)   # torch.flatten(x，0)默认将张量拉成一维的向量 
"""
tensor([-0.6146, -0.4504,  0.8746, -0.3938,  0.3173, -1.1811,  0.5384, -0.3661,
         0.0720,  0.0589,  1.2766,  0.9657,  0.6871, -0.3208,  1.5013, -1.2017])""" 
torch.flatten(x,1) # torch.flatten(x，1)代表从第二维开始平坦化。 

"""
tensor([[-0.7490, -0.0988,  1.0184, -0.9379,  0.1239,  0.4755,  2.3892,  0.2938],
        [ 0.8259,  1.0124, -1.0816,  1.2954, -0.3740, -0.0886, -1.9905, -0.0894]])"""

torch.flatten(x,0,1) # torch.flatten(x,0,1) 代表从第一维和第二维之间开始平坦化 
"""
tensor([[ 0.7250, -0.2884],
        [-0.9310, -0.1806],
        [ 0.0274,  0.7511],
        [ 2.1714,  0.5674],
        [ 0.4714, -0.3969],
        [-0.3728, -0.2347],
        [-1.3916, -0.3617], 
        [ 1.6371, -1.5746]])""" 

import torch
#随机32个通道为1的5*5的图
x=torch.randn(32,1,5,5)
 
model=torch.nn.Sequential(
    #输入通道为1，输出通道为 6，3*3的卷积核，步长为1，padding=1
    torch.nn.Conv2d(1,6,3,1,1),
    torch.nn.Flatten()
)
output=model(x)
print(output.shape)  # 6*（7-3+1）*（7-3+1）

torch.Size([32, 150])

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

从给定均值和标准差的正态分布N(mean, std)中生成值，填充输入的张量或变量 ,但是我们上文中使用的是 torch.nn.init.normal_()并非没有带下划线的。

一般这种带有下划线的torch.nn.init.normal_()我们称之为这个方法的in-place操作，in-place操作，意思是所有的操作都是“就地”操作，不允许进行移动，或者称作 原位操作，即不允许使用临时变量。

比如说现在我们有两个变量x,y ，我想要交换它们的值，最常用的就是创建一个临时的变量去接收它们:

x = 1000 ,y=2000 
temp = x 
x = y 
y = temp 

而in-place操作就是不用任何的临时变量，不复制任何的内容。

x = x + y;
y = x - y;
x = x - y;

或者： 异或运算

x = x ^ y;
y = x ^ y;
x = x ^ y;

一般来说，我们不会再复杂的神经网络也不推荐在神经网络使用in-place操作，具体访问： https://www.sohu.com/a/443562356_100007727

3. 关于torch.nn.Sequential()之后为何使用 .apply()函数，官方给出的例子如下：

import torch
from torch import nn 
@torch.no_grad()
def init_weights(m):
    print(m)
    if type(m) == nn.Linear:
        m.weight.fill_(1.0)
        print(m.weight)
net = nn.Sequential(nn.Linear(2, 2), nn.Linear(2, 2))
net.apply(init_weights)

更详细了解访问官网了解： https://pytorch.org/docs/stable/generated/torch.nn.Module.html?highlight=apply#torch.nn.Module.apply

4.torch.optim.SGD() 使用方式：Pytorch官网给出示例：

from torch import optim 
import torch 

model = torch.nn.Sequential(torch.nn.Linear(2,2))
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

更多详情访问官网： https://pytorch.org/docs/stable/optim.html 访问官网之后按住Ctrl+F 搜索：optim.SGD 便可以找到

参考文章/文献：
https://www.pytorchtutorial.com/docs/package_references/torch-autograd/ 为什么不推荐使用in-place方法