深度学习计算

文章目录

• 深度学习计算
• • 层和块
  • • 自定义块
    • 顺序块
    • 在正向传播函数中执行代码
    • 混搭各种组合块
  • 参数管理
  • • 参数访问
    • 参数初始化
    • 自定义层
    • 读写文件
    • GPU

层和块

单个神经元：

• 接收一组输入。
• 生成相应的标量输出。
• 具有一组相关参数（这些参数可以更新以优化感兴趣的目标函数）。
  层：
• 接受一组输入。
• 生成相应的输出。
• 有一组可调整参数描述。
  为了实现这些复杂的⽹络，我们引⼊了神经⽹络块的概念。块可以描述单个层、由多个层组成的组件或整个
  模型本⾝。使⽤块进⾏抽象的⼀个好处是可以将⼀些块组合成更⼤的组件，这⼀过程通常是递归的。

import torch
from torch import nn
from torch.nn import functional as F
net = nn.Sequential(nn.Linear(20, 256), nn.ReLU(), nn.Linear(256, 10))
X = torch.rand(2, 20)
net(X)

自定义块

每个块必须提供的基本功能：

• 将输⼊数据作为其正向传播函数的参数。
• 通过正向传播函数来⽣成输出。请注意，输出的形状可能与输⼊的形状不同。
• 计算其输出关于输⼊的梯度，可通过其反向传播函数进⾏访问。通常这是⾃动发⽣的。
• 存储和访问正向传播计算所需的参数。
• 根据需要初始化模型参数。

class MLP(nn.Module):
  # ⽤模型参数声明层。这⾥，我们声明两个全连接的层
  def __init__(self):
    # 调⽤`MLP`的⽗类`Block`的构造函数来执⾏必要的初始化。
    # 这样，在类实例化时也可以指定其他函数参数，例如模型参数`params`（稍后将介绍）
    super().__init__()
    self.hidden = nn.Linear(20, 256) # 隐藏层
    self.out = nn.Linear(256, 10) # 输出层
  # 定义模型的正向传播，即如何根据输⼊`X`返回所需的模型输出
  def forward(self, X):
    # 注意，这⾥我们使⽤ReLU的函数版本，其在nn.functional模块中定义。
    return self.out(F.relu(self.hidden(X)))

net=MLP()
net(X)

顺序块

class MySequential(nn.Module):
  def __init__(self, *args):
    super().__init__()
    for block in args:
      # 这⾥，`block`是`Module`⼦类的⼀个实例。我们把它保存在'Module'类的成员变量
      # `_modules` 中。`block`的类型是OrderedDict。
      self._modules[block] = block
  def forward(self, X):
    # OrderedDict保证了按照成员添加的顺序遍历它们
    for block in self._modules.values():
      X = block(X)
    return X
    
net = MySequential(nn.Linear(20, 256), nn.ReLU(), nn.Linear(256, 10))
net(X)

在正向传播函数中执行代码

class FixedHiddenMLP(nn.Module):
  def __init__(self):
    super().__init__()
    # 不计算梯度的随机权重参数。因此其在训练期间保持不变。
    self.rand_weight = torch.rand((20, 20), requires_grad=False)
    self.linear = nn.Linear(20, 20)
  def forward(self, X):
    X = self.linear(X)
    # 使⽤创建的常量参数以及`relu`和`dot`函数。
    X = F.relu(torch.mm(X, self.rand_weight) + 1)
    # 复⽤全连接层。这相当于两个全连接层共享参数。
    X = self.linear(X)
    # 控制流
    while X.abs().sum() > 1:
      X /= 2
    return X.sum()

net = FixedHiddenMLP()
net(X)

混搭各种组合块

class NestMLP(nn.Module):
  def __init__(self):
    super().__init__()
    self.net = nn.Sequential(nn.Linear(20, 64), nn.ReLU(),
        nn.Linear(64, 32), nn.ReLU())
    self.linear = nn.Linear(32, 16)
  def forward(self, X):
    return self.linear(self.net(X))
chimera = nn.Sequential(NestMLP(), nn.Linear(16, 20), FixedHiddenMLP())
chimera(X)

参数管理

一旦我们选择了架构并设置了超参数，我们就进入了训练阶段。此时，我们的目标是找到使损失函数最小化的参数值。经过训练后，我们将需要使用这些参数来做出未来的预测。此外，我们还希望能够提取参数，以便在其他环境中复用它们，将模型保存到磁盘，以便它可以在其他软件中执行，或者为了获得科学的理解进而进行检查。
本节主要实现以下内容：

• 访问参数，用于调试、诊断和可视化。
• 参数初始化。
• 在不同模型组件间共享参数。
  在单隐藏层的多层感知机。

import torch
from torch import nn
net = nn.Sequential(nn.Linear(4, 8), nn.ReLU(), nn.Linear(8, 1))
X = torch.rand(size=(2, 4))
net(X)

参数访问

从已有模型中访问参数。当通过Sequential类定义模型时，我们可以通过索引来访问模型的任意层。这就像模型是一个列表一样。每层的参数都在其属性中。如下代码所示，我们可以检查第二个全连接层的参数。

print(net[2].state_dict())

目标参数
每个参数都表示为参数类的一个实例。要对参数执行任何操作，首先我们需要访问底层的数值。有几种方法可以做到这一点。有些比较简单，而另一些则比较通用。下面的代码从第二个神经网络提取偏置，提取后返回的是一个参数类实例，并进一步访问该参数的值。

print(type(net[2].bias))
print(net[2].bias)
print(net[2].bias.data)

参数是复合的对象，包含值、梯度和额外的信息。这就是我们需要显示请求值的原因。
除了值之外，我们还可以访问每个参数的梯度。由于我们还没有调用这个网络的反向传播，所以参数的梯度还处于初始状态。

net[2].weight.grad == None

一次性访问所有参数
当我们需要对所有参数执行操作时，逐个访问它们可能会很麻烦。当我们处理更复杂的块（如，嵌套块）时，情况可能会变得特别复杂，因为我们需要递归整个树来提取每个子块的参数。
下面我们将通过演示来比较访问第一个全连接层的参数和访问所有层。

print(*[(name, param.shape) for name, param in net[0].named_parameters()])
print(*[(name, param.shape) for name, param in net.named_parameters()])

这里还有另一种访问网络参数的方式，如下所示。

net.state_dict()['2.bias'].data

从嵌套块收集参数
如果我们将多个块相互嵌套，参数命名约定是如何工作的。为此，我们首先定义一个生成块的函数（可以说是块工厂），然后将这些块组合到更大的块中。

def block1():
  return nn.Sequential(nn.Linear(4, 8), nn.ReLU(),
      nn.Linear(8, 4), nn.ReLU())
def block2():
  net = nn.Sequential()
  for i in range(4):
    # 在这⾥嵌套
    net.add_module(f'block {i}', block1())
  return net

rgnet = nn.Sequential(block2(), nn.Linear(4, 1))
rgnet(X)

现在来看看网络是如何组织的。

print(rgnet)

Sequential(
  (0): Sequential(
    (block 0): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
    (block 1): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
    (block 2): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
    (block 3): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
  )
  (1): Linear(in_features=4, out_features=1, bias=True)
)

因为层是分层嵌套的，所以我们也可以像通过嵌套列表索引一样访问它们。 例如，我们下面将访问第一个主要的块，其中第二个子块的第一层的偏置项。

rgnet[0][1][0].bias.data

参数初始化

我们上边了解到了如何访问参数，现在让我们看看如何正确的初始化参数。在前边讨论了良好初始化的必要。深度学习框架提供默认随机初始化。然而，我们经常希望根据其他规则初始化权重。深度学习框架提供了最常用的规则，也允许自定义初始化方法。
默认情况下，pytorch会根据一个范围均匀地初始化权重和偏置矩阵，这个范围是根据输入和输出的维度计算出的，pytorch的nn.init模块提供了多张预置初始化方法。
内置初始化
首先调用内置的初始化器。下面的代码将所有权重参数初始化为标准差为0.01的高斯随机变量，且偏置参数设置为0。

def init_normal(m):
  if type(m) == nn.Linear:
    nn.init.normal_(m.weight, mean=0, std=0.01)
    nn.init.zeros_(m.bias)
net.apply(init_normal)
net[0].weight.data[0], net[0].bias.data[0]

我们还可以将所有参数初始化为给定的常数（比如1）。

def init_constant(m):
  if type(m) == nn.Linear:
    nn.init.constant_(m.weight, 1)
    nn.init.zeros_(m.bias)
net.apply(init_constant)
net[0].weight.data[0], net[0].bias.data[0]

我们还可以对某些块应用不同的初始化方法。例如，下面我们使用Xavier方法初始化第一层，然后第二层初始化为常量42。

def xavier(m):
  if type(m) == nn.Linear:
    nn.init.xavier_uniform_(m.weight)
def init_42(m):
  if type(m) == nn.Linear:
    nn.init.constant_(m.weight, 42)
net[0].apply(xavier)
net[2].apply(init_42)
print(net[0].weight.data[0])
print(net[2].weight.data)

自定义初始化
有时，深度学习框架没有提供我们需要的初始化方法。在下边的例子中，我们使用以下分布为任意权重参数w定义初始化方法：

同样，我们实现了一个my_init函数来应用到net。

def my_init(m):
  if type(m) == nn.Linear:
    print("Init", *[(name, param.shape)
      for name, param in m.named_parameters()][0])
    nn.init.uniform_(m.weight, -10, 10)
    m.weight.data *= m.weight.data.abs() >= 5

net.apply(my_init)
net[0].weight[:2]

注意，我们始终可以直接设置参数。

net[0].weight.data[:] += 1
net[0].weight.data[0, 0] = 42
net[0].weight.data[0]

参数绑定
有时，我们希望在多个层间共享参数。让我们看看如何优雅地做这件事情。在下面，我们定义一个稠密层，然后使用它的参数来设置另一个层的参数。

# 我们需要给共享层⼀个名称，以便可以引⽤它的参数。
shared = nn.Linear(8, 8)
net = nn.Sequential(nn.Linear(4, 8), nn.ReLU(),
    shared, nn.ReLU(),
    shared, nn.ReLU(),
    nn.Linear(8, 1))
net(X)
# 检查参数是否相同
print(net[2].weight.data[0] == net[4].weight.data[0])
net[2].weight.data[0, 0] = 100
# 确保它们实际上是同⼀个对象，⽽不只是有相同的值。
print(net[2].weight.data[0] == net[4].weight.data[0])

这个例子表明第二层和第三层的参数是绑定的。它们不仅值相等，而且由相同的张量表示。因此，如果我们改变其中一个参数，另一个参数也会改变。当参数绑定时，梯度会发生什么变化？答案是由于模型参数包含梯度，因此在反向传播起见第二个隐藏层和第三个隐藏层的梯度会加在一起。

自定义层

深度学习成功背后的一个因素是，可以用创造性的方式组合广泛的层，从而设计出适用各种任务的结构。例如，研究人员发明了专门用于处理图像、文本、序列数据和执行动态编程的层。
早晚有一天，你会遇到或要自己发明一个在深度学习框架中还不存在的层。在这些情况下，你必须构建自定义层。

不带参数的层
首先，我们构造一个没有任何参数的自定义层。下面的CenterdLayer类要从其输入中减去均值。要构建它，我们只需要继承基础类并实现正向传播功能。

import torch
import torch.nn.functional as F
from torch import nn
class CenteredLayer(nn.Module):
  def __init__(self):
    super().__init__()
  def forward(self, X):
    return X - X.mean()
layer = CenteredLayer()
layer(torch.FloatTensor([1, 2, 3, 4, 5]))

现在，我们可以将层作为组件合并到构建更复杂的模型中。

net = nn.Sequential(nn.Linear(8, 128), CenteredLayer())

作为额外的健全性检查，我们可以向网络发送随机数据后，检查均值是否为0。由于我们处理的是浮点数，因为存储精度的原因，我们仍可能会看到一个非常小的非零数。

Y = net(torch.rand(4, 8))
Y.mean()

带参数的层
上边我们知晓了如何定义简单的层，那么我们继续定义具有参数的层，这些参数可以通过训练进行调整。我们可以使用内置函数来创建参数，这些函数提供一些基本的管理功能。比如管理访问、初始化、共享、保存和加载模型参数。这样做的好处之一是，我们不需要为每个自定义层编写自定义序列化程序。
现在，我们实现自定义版本的全连接层。回想一下，这个层需要两个参数，一个用于表示权重，另一个用于表示偏置项。在此实现中，我们使用ReLU作为激活函数。该层需要输入参数：in_units和units，分别表示输入和输出的数量。

class MyLinear(nn.Module):
  def __init__(self, in_units, units):
    super().__init__()
    self.weight = nn.Parameter(torch.randn(in_units, units))
    self.bias = nn.Parameter(torch.randn(units,))
  def forward(self, X):
    linear = torch.matmul(X, self.weight.data) + self.bias.data
    return F.relu(linear)

接下来，我们实例化MyLinear类并访问其模型参数。

linear = MyLinear(5, 3)
linear.weight

我们可以使用自定义层直接执行正向传播计算。

linear(torch.rand(2, 5))

我们还可以使用自定义层构建模型。我们可以像使用内置的全连接层一样使用自定义层。

net = nn.Sequential(MyLinear(64, 8), MyLinear(8, 1))
net(torch.rand(2, 64))

读写文件

到目前为止，我们讨论了如何训练数据，以及如何构建、训练和测试深度学习模型。然而，有时我们对所学的模型足够满意，我们希望保存训练的模型以备将来在各种环境中使用（甚至可能在部署中进行预测），此外，当运行一个耗时比较长的训练过程时，最佳的做法是定期保存中间结果（检查点），以确保在服务器电源被不小心断掉时不会损失几天的计算结构。因此，现在是时候学习如何加载和存储权重向量和整个模型。
加载和保存张量
对于单个张量，我们可以直接调用load和save函数分别读写它们。这两个函数都要求我们提供一个名称，save要求将要保存的变量作为输入。

import torch
from torch import nn
from torch.nn import functional as F
x = torch.arange(4)
torch.save(x, 'x-file')

现在将存储在文件中的数据读回内存。

x2 = torch.load('x-file')
x2

我们可以存储一个张量列表，然后把它们读回内存。

y = torch.zeros(4)
torch.save([x, y],'x-files')
x2, y2 = torch.load('x-files')
(x2, y2)

甚至可以写入或读取从字符串映射到张量的字典。当我们要读取或写入模型中的所有权重时，这很方便。

mydict = {'x': x, 'y': y}
torch.save(mydict, 'mydict')
mydict2 = torch.load('mydict')
mydict2

加载和保存模型参数
保存单个权重向量确实是有用的，但是如果我们想保存整个模型，并在以后加载它们，单独去保存每个向量会变得非常麻烦。因此，深度学习框架提供了内置函数来保存和加载整个网络。需要注意的是，这将要保存的是模型的参数而不是保存整个模型。

class MLP(nn.Module):
def __init__(self):
super().__init__()
self.hidden = nn.Linear(20, 256)
self.output = nn.Linear(256, 10)
def forward(self, x):
return self.output(F.relu(self.hidden(x)))
net = MLP()
X = torch.randn(size=(2, 20))
Y = net(X)

接下来，我们将模型的参数存储为一个叫做“mlp.params”的文件。

torch.save(net.state_dict(), 'mlp.params')

为了恢复模型，我们实例化了原始多层感知机模型的一个备份。我们没有随机初始化模型参数，而是直接读取文件中存储的参数。

clone = MLP()
clone.load_state_dict(torch.load('mlp.params'))
clone.eval()

由于两个实例具有相同的模型参数，在输入相同的X时，两个实例的计算结果应该相同。下边是验证。

Y_clone = clone(X)
Y_clone == Y

GPU

gpu部分目前十分不熟悉，以后回来补上！