Pytorch基础(4)——线性回归简介实现笔记

• torch.utils.data 读取数据

1. 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 定义模型

1. 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 模块提供了模型参数初始化的各种⽅法。