动手学深度学习--4、深度学习计算

4.1 模型构造

 让我们回顾一下在3.10节（“多层感知机的简洁实现”）一节中含单隐藏层的多层感知机的实现方法。我们首先构造Sequential实例，然后一次添加两个全连接层。其中第一层的输出大小为256，即隐藏层单元个数是256；第二层的输出大小为10，即输出层单元个数是10.我们在上一章的其他节中页使用了Sequential类构造模型。这里我们介绍另外一种基于tf.keras.Model类的模型构造方法：它让模型构造更加灵活。#哪里体现灵活？？

4.1.1 build model from block

 tf.keras.Model类是tf.keras模块里提供的一个模型构造类，我们可以继承它来定义我们想要的模型。下面集成tf.keras.Model类构造本节开头提到的多层感知机。这里定义的MLP类重载了tf.keras.Model类的__init__函数和forward函数。它们分别用于创建模型参数和定义前向计算。前向计算也即正向传播。

import tensorflow as tf
import numpy as np
class MLP(tf.keras.Model):
    def __init__(self):
        super().__init__()
        self.flatten = tf.keras.layers.Flatten() #Flatten层将除第一维（batch_size）以外的维度展评
        self.dense1 = tf.keras.layers.Dense(units = 256, activation = tf.nn.relu)
        self.dense2 = tf.keras.layers.Dense(units = 10)
    
    def forward(self, inputs):
        x = self.flatten(inputs)
        x = self.dense1(x)
        output = self.dense2(x)
        return output

以上的MLP类中无须定义反向传播函数。系统将通过自动求梯度而自动生成反向传播所需的backward函数。我们可以实例化MLP类得到模型变量net。下面的代码初始化net并传入数据X做一次前向计算。其中，net(X)将调用MLP类定义的forward函数来完成前向计算。

X = tf.random.uniform((2,20))
net = MLP()
net(X)

4.1.2 Sequential

&我们刚刚提到，tf.keras.Model类是一个通用的部件。事实上，Sequential类继承自tf.keras.Model类。当模型的前向计算为简单串联各个层的计算时，可以通过简单的方式定义模型。这正是Sequential类的目的：它提供add函数来逐一添加串联的Block子类实例，而模型的前向计算就是将这些实例按添加的顺序逐一计算。我们用Sequential类来实现前面描述的MLP类，并使用随机初始化的模型做一次前向计算。

model = tf.keras.models.Sequential([
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(256,activation=tf.nn.relu),
    tf.keras.layers.Dense(10)
])
model(X)

4.1.3 构造复杂的模型（重点）

  虽然Sequential类可以使模型构造更加简单，且不需要定义forward函数，但直接集成tf.keras.Model类可以极大的拓展模型构造的灵活性。下面我们构造一个稍微复杂点的网络FancyMLP。在这个网络中，我们通过constant函数创建训练中不被迭代的参数，即常数参数。在前向计算中，除了使用创建的常数参数外，我们还使用tensor的函数和python的控制流，并多次调用相同的层。

class FancyMLP(tf.keras.Model):
    def __init__()
        super().__init__()
        self.flatten = tf.keras.layers.Flatten()
        self.rand_weight = tf.constant(tf.random.uniform((20,20))) #使用tf.constant创建的随机权重参数不会在训练中被迭代（即常数参数）
        self.dense = tf.keras.layers.Dense(units = 20, activation = tf.nn.relu)

    def forward(self, x):
        x = self.dense(x)
        x = tf.nn.relu(tf.matmul(x, self.rand_weight) + 1)
        x = self.dense(x)
        while tf.norm(x) > 1:
            x /= 2
        if tf.norm(x) < 0.8:
            x *= 10
        return tf.reduce_sum(x)

在这个fancyMLP模型中，我们使用了常数权重rand_weight（注意它不是模型参数）、做了矩阵乘法操作(tf.matmul)并重复(体现在了哪里？？)使用了相同的Dense层。下面我们来测试该模型的随机初始化和前向计算。

net = FancyMLP()
net(X)

因为FancyMLP和Sequential类都是tf.keras.Model类的子类，所以我们可以嵌套调用它们。

class NestMLP(tf.keras.Model):  #构造的网络结构是什么样的？？
    def __init__(self):
        super().__init__()
        self.net = tf.keras.Sequential() #self.net和self.dense的联系和区别
        self.net.add(tf.keras.layers.Flatten()) #add的作用是什么？
        self.net.add(tf.keras.layers.Dense(64, activation = tf.nn.relu))
        self.net.add(tf.keras.layers.Dense(32, activation = tf.nn.relu))
        self.dense = tf.keras.layers.Dense(units = 16, activation = tf.nn.relu) #self.dense的含义？

    def forward(self, inputs):
        return self.dense(self.net(inputs))

net = tf.keras.Sequential()
net.add(NestMLP())
net.add(tf.keras.layers.Dense(20))
net.add(FancyMLP())  #net.add的作用，网络结构长什么样？
net(X)

小结

 我们可以通过集成Block类类构造模型；
 Sequential类继承自Block类
 虽然Sequential类可以使得模型构造更加简单，但直接集成Block类可以极大地拓展模型构造的灵活性。

4.2 模型参数的访问、初始化和共享

  在3.3节（“线性回归简洁实现”）一节中，我们通过init模块来初始化模型的全部参数。我们页介绍了访问模型参数的简单方法。本节将深入讲解如何访问和初始化模型参数，以及如何在多个层之间共享同一份模型参数。我们先定义一个与上一节中相同的含单隐藏层的多层感知机。我们依然使用默认方式初始化它的参数，并做一次前向计算。

net = tf.keras.models.Sequential()
net.add(tf.keras.layers.Flatten())
net.add(tf.keras.layers.Dense(256,activation=tf.nn.relu))
net.add(tf.keras.layers.Dense(10))

X = tf.random.uniform((2,20))
Y = net(X)
Y

4.2.1 访问模型参数

 对于使用Sequential类构造神经网络，我们可以通过weights属性来访问网络任一层的权重。回忆上一节中提到的Sequential类与tf.keras.Model类的集成关系。对于Sequential实例中含模型参数的层，我们可以通过tf.keras.Model类的weights属性来访问该层包含的所有参数。下面，访问多层感知机net中隐藏层的所有参数，索引0表示隐藏层为Sequential实例最先添加的层。

net.weight[0], type(net.weights[0])

可以看到，我们得到了一个由参数名称映射到参数实例的字典（类型为ParameterDict类）。其中权重参数的名称为dense0_weight，它由net[0]的名称（dense0_）和自己的变量名（weight）组成。而且可以看到，该参数的形状为(256,20)，且数据类型为32位浮点数（float32）。为了访问特定参数，我们既可以通过名字来来访问字典里的元素，页可以直接使用它的变量名。下面两种方法是等价的，但通常后者的代码可读性更好。

net[0].params['dense0_weight']
net[0].weight

梯度的形状跟权重一样，由于我们还没有进行反向传播，所以梯度的值全为0。

net[0].weight.grad()

类似地，我们可以访问其他层的参数，例如输出层的偏差值。

net[1].bias.data()

最后，我们可以使用collect_params函数来获取net变量所有嵌套（例如通过add函数嵌套）的层所包含的所有参数。它返回的同样是一个有参数名称到参数实例的字典

net.collect_params()

这个函数可以通过正则化表达式来匹配参数名，从而筛选需要的参数

net.collect_params('.*weight')

4.2.2 模型参数的访问、初始化和共享

 我们在（“数值稳定性和模型初始化”）一节中描述了模型的默认初始化方法：权重参数元素为[-0.07, 0.07]之间均匀分布的随机数，偏差参数则全为0.但我们经常需要使用其他方法来初始化权重。在下面的例子中，我们将权重参数初始化成均值为0、标准差为0.01的正态分布随机数，并依然将偏差参数清零。

class Linear(tf.keras.Model):  #需要修改
    def __init__(self):
        super().__init__()
        self.d1 = tf.keras.layers.Dense(
            units = 10,
            activation = None,
            kernel_initializer = tf.zeros_initializer(), 
            bias_initializer = tf.zeros_initializer()
        )
        self.d2 = tf.keras.layers.Dense(  #使用常数来初始化权重参数
            units = 1,
            activation = None,
            kernel_initializer = tf.ones_initializer(),
            bias_initializer = tf.ones_initializer()
        )

如果想只对某个特定参数进行初始化，我们可以调用Paramter类的initialize函数，它与Block类提供的initialize函数的使用方法一致。下例中我们对隐藏层的权重使用了Xavier初始化方法

#自己写

4.2.3 自定义初始化方法

 有时候我们需要的初始化方法并没有在init模块中提供，这时我们可以实现一个Initializer类的子类，从而能够像使用其他初始化方法那样使用它。在下面的例子里，我们令权重的一半概率初始化为0，另一半初始化为[-10,-5]和[5,10]两个区间均匀分布的随机数

def my_init():
    def _init_weight(self, name, data):
        print('Init', name, data.shape)
        data[:] = np.random.uniform(low = -10, high = 10, shape = data.shape)
        data += data.abs()>=5
    net.initialize(my_init(), froce_reinit=True)
    net.weight.data()[0]

Init dense0_weight(256, 20)
Init dense_weight(10, 256)

此外，我们还可以通过Parameter类的set_data函数来直接改写模型参数。例如下例中我们将隐藏层参数在现有的基础上加1

net[0].weight.set_data(net[0].weight.data()+1)
net[0].weight.data()[0]
``
### 4.2.4 共享模型参数
  在有些情况下，我们希望在多个层之间共享模型参数。“模型构造”一节介绍了如何在Block类的forward函数里多次调用同一个层来计算。这里再介绍另外一个方法，它在构造层的时候指定使用特定的参数。如果不同层使用同一份参数，那么它们前向计算和反向传播时都会共享相同的参数。在下面的例子里，我们让模型的第二隐藏层和第三隐藏层共享模型参数。
# 4.3 模型参数的延后初始化
# 4.4 自定义层
# 4.5 读取和存储
# 4.6 GPU计算