-
torch.utils.data 读取数据
-
PyTorch 提供了 data 包来读取数据。
import torch.utils.data as Data batch_size = 10 # 将训练数据的特征和标签组合 dataset = Data.TensorDataset(features, labels) # 随机读取⼩批量 data_iter = Data.DataLoader(dataset, batch_size, shuffle=True)
-
torch.nn 定义模型
-
PyTorch提供了⼤量预定义的层，这使我们只需关注使⽤哪些层来构造模型。torch.nn 模块定义了⼤量神经⽹络的层，nn 的核⼼数据结构是 Module ，它是⼀个抽象概念，既可以表示神经⽹络中的某个层（layer），也可以表示⼀个包含很多层的神经⽹络。在实际使⽤中，最常⻅的做法是继承 nn.Module ，实现构造函数__init__和forward这两个方法，撰写⾃⼰的⽹络/层。⼀个 nn.Module 实例应该包含⼀些层以及返回输出的前向传播（forward）⽅法。下⾯先来看看如何⽤ nn.Module 实现⼀个线性回归模型。
class LinearNet(nn.Module): def __init__(self, n_feature): super(LinearNet, self).__init__() # 调用父类的构造函数 self.linear = nn.Linear(n_feature, 1) # forward 定义前向传播 def forward(self, x): y = self.linear(x) return y net = LinearNet(num_inputs) print(net) # 使⽤print可以打印出⽹络的结构有一些注意技巧：
（1）一般把网络中具有可学习参数的层（如全连接层、卷积层等）放在构造函数__init__()中
（2）一般把不具有可学习参数的层(如ReLU、dropout、BatchNormanation层)可放在构造函数中，也可不放在构造函数中，如果不放在构造函数__init__里面，则在forward方法里面可以使用nn.functional来代替
（3）forward方法是必须要重写的，它是实现模型的功能，实现各个层之间的连接关系的核心。下面先看一个简单的例子。
import torch class MyNet(torch.nn.Module): def __init__(self): super(MyNet, self).__init__() # 第一句话，调用父类的构造函数 self.conv1 = torch.nn.Conv2d(3, 32, 3, 1, 1) self.relu1=torch.nn.ReLU() self.max_pooling1=torch.nn.MaxPool2d(2,1) self.conv2 = torch.nn.Conv2d(3, 32, 3, 1, 1) self.relu2=torch.nn.ReLU() self.max_pooling2=torch.nn.MaxPool2d(2,1) self.dense1 = torch.nn.Linear(32 * 3 * 3, 128) self.dense2 = torch.nn.Linear(128, 10) def forward(self, x): x = self.conv1(x) x = self.relu1(x) x = self.max_pooling1(x) x = self.conv2(x) x = self.relu2(x) x = self.max_pooling2(x) x = self.dense1(x) x = self.dense2(x) return x model = MyNet() print(model) '''运行结果为： MyNet( (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) (relu1): ReLU() (max_pooling1): MaxPool2d(kernel_size=2, stride=1, padding=0, dilation=1, ceil_mode=False) (conv2): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) (relu2): ReLU() (max_pooling2): MaxPool2d(kernel_size=2, stride=1, padding=0, dilation=1, ceil_mode=False) (dense1): Linear(in_features=288, out_features=128, bias=True) (dense2): Linear(in_features=128, out_features=10, bias=True) ) '''注意：上面的是将所有的层都放在了构造函数__init__里面，但是只是定义了一系列的层，各个层之间到底是什么连接关系并没有，而是在forward里面实现所有层的连接关系，当然这里依然是顺序连接的。下面再来看一下一个例子：
import torch import torch.nn.functional as F class MyNet(torch.nn.Module): def __init__(self): super(MyNet, self).__init__() # 第一句话，调用父类的构造函数 self.conv1 = torch.nn.Conv2d(3, 32, 3, 1, 1) self.conv2 = torch.nn.Conv2d(3, 32, 3, 1, 1) self.dense1 = torch.nn.Linear(32 * 3 * 3, 128) self.dense2 = torch.nn.Linear(128, 10) def forward(self, x): x = self.conv1(x) x = F.relu(x) x = F.max_pool2d(x) x = self.conv2(x) x = F.relu(x) x = F.max_pool2d(x) x = self.dense1(x) x = self.dense2(x) return x model = MyNet() print(model) '''运行结果为： MyNet( (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) (conv2): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) (dense1): Linear(in_features=288, out_features=128, bias=True) (dense2): Linear(in_features=128, out_features=10, bias=True) ) '''注意：此时，将没有训练参数的层没有放在构造函数里面了，所以这些层就不会出现在model里面，但是运行关系是在forward里面通过functional的方法实现的。
总结：所有放在构造函数__init__里面的层的都是这个模型的“固有属性”.
事实上我们还可以⽤ nn.Sequential 来更加⽅便地搭建⽹络， Sequential 是⼀个有序的容器，⽹络层将按照在传⼊ Sequential 的顺序依次被添加到计算图中。# 写法⼀ net = nn.Sequential( nn.Linear(num_inputs, 1) # 此处还可以传⼊其他层 ) # 写法⼆ net = nn.Sequential() net.add_module('linear', nn.Linear(num_inputs, 1)) # net.add_module ...... # 写法三 from collections import OrderedDict net = nn.Sequential(OrderedDict([ ('linear', nn.Linear(num_inputs, 1)) # ...... ])) print(net) print(net[0]) # 输出 Sequential( (linear): Linear(in_features=2, out_features=1, bias=True) ) Linear(in_features=2, out_features=1, bias=True)可以通过 net.parameters() 来查看模型所有的可学习参数，此函数将返回⼀个⽣成器。for param in net.parameters(): print(param) # 输出 Parameter containing: tensor([[-0.0277, 0.2771]], requires_grad=True) Parameter containing: tensor([0.3395], requires_grad=True)
-
torch.nn.init 初始化模型参数
在使⽤ net 前，我们需要初始化模型参数，如线性回归模型中的权重和偏差。PyTorch在 init 模块中提供了多种参数初始化⽅法。这⾥的 init 是 initializer 的缩写形式。我们通init.normal_ 将权重参数每个元素初始化为随机采样于均值为0、标准差为0.01的正态分布。偏差初始化为零。from torch.nn import init init.normal_(net[0].weight, mean=0, std=0.01) init.constant_(net[0].bias, val=0) # 也可以直接修改bias的data: net[0].bias.data.fill_(0) -
定义损失函数
PyTorch 在 nn 模块中提供了各种损失函数，这些损失函数可看作是⼀种特殊的层， PyTorch 也将这些损 失函数实现为 nn.Module 的⼦类。我们现在使⽤它提供的均⽅误差损失作为模型的损失函数。loss = nn.MSELoss() -
torch.optim定义优化算法
我们也⽆须⾃⼰实现⼩批量随机梯度下降算法。
torch.optim
模块提供了很多常⽤的优化算法
⽐如
SGD
、
Adam
和
RMSProp
等。下⾯我们创建⼀个⽤于优化
net
所有参数的优化器实例，并指定学 习率为0.03
的⼩批量随机梯度下降（
SGD
）为优化算法。
import torch.optim as optim
optimizer = optim.SGD(net.parameters(), lr=0.03)
print(optimizer)
# 输出
SGD (
Parameter Group 0
dampening: 0
lr: 0.03
momentum: 0
nesterov: False
weight_decay: 0
)
我们还可以为不同⼦⽹络设置不同的学习率，这在
finetune
时经常⽤到。例：
optimizer =optim.SGD([
# 如果对某个参数不指定学习率，就使⽤最外层的默认学习率
{'params': net.subnet1.parameters()}, # lr=0.03
{'params': net.subnet2.parameters(), 'lr': 0.01}
], lr=0.03)
有时候我们不想让学习率固定成⼀个常数，那如何调整学习率呢？主要有两种做法。⼀种是修
改
optimizer.param_groups
中对应的学习率，另⼀种是更简单也是较为推荐的做法
——
新建优化 器，由于optimizer
⼗分轻量级，构建开销很⼩，故⽽可以构建新的
optimizer
。但是后者对于使⽤动量 的优化器（如Adam
），会丢失动量等状态信息，可能会造成损失函数的收敛出现震荡等情况。
# 调整学习率
for param_group in optimizer.param_groups:
param_group['lr'] *= 0.1 # 学习率为之前的0.1倍-
训练模型
我们通过调⽤ optim 实例的 step 函数来迭代模型参数。按照⼩批量随机梯度下降的定义，我们在 step 函数中指明批量⼤⼩，从⽽对批量中样本梯度求平均。optimizer . step ()用来更新参数。num_epochs = 3 for epoch in range(1, num_epochs + 1): for X, y in data_iter: output = net(X) l = loss(output, y.view(-1, 1)) optimizer.zero_grad() # 梯度清零，等价于net.zero_grad() l.backward() optimizer.step() print('epoch %d, loss: %f' % (epoch, l.item())) # 输出 epoch 1, loss: 0.000457 epoch 2, loss: 0.000081 epoch 3, loss: 0.000198下⾯我们分别⽐较学到的模型参数和真实的模型参数。我们从 net 获得需要的层，并访问其权重（ weight ）和偏差（ bias ）。学到的参数和真实的参数很接近。dense = net[0] print(true_w, dense.weight) print(true_b, dense.bias) # 输出 [2, -3.4] tensor([[ 1.9999, -3.4005]]) 4.2 tensor([4.2011]) -
小结
使⽤PyTorch可以更简洁地实现模型，torch.utils.data 模块提供了有关数据处理的⼯具， torch.nn 模块定义了⼤量神经⽹络的层， torch.nn.init 模块定义了各种初始化⽅法，torch.optim 模块提供了模型参数初始化的各种⽅法。
715
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
