本章节为<<动手学深度学习>>的知识点整理。

深度学习基础

线性回归

注：线性回归为一个单层的神经网络

线性回归的基本要素

模型

设房屋面积为x1，房龄为x2，售出价格为y，我们需要建立基于输入x1和x2来计算输出y的表达式，即模型，线性回归假设输出与各个输入之间是线性关系，则我们有公式

$y^*=x_1w_1+x_2w_2+b$

其中w1,w2是权重，b是偏差。模型输出是线性回归对于真实价格y的预测与估计。

模型训练

我们需要寻找特定的模型的参数值，使得模型在数据上的误差尽可能的小。

训练数据

我们收集一系列的数据，在这个数据上面寻找模型参数来使得模型的预测价格与真实价格的误差最小。这个数据集被称之为训练集。

假设我们采集的样本数为n，索引为i的样本的特征为和，标签为，对于索引为i的房屋，线性回归模型的房屋价格预测表达式为

$y^{*(i)}=x^{i}_1w_1+x^{i}_2w_2+b$

损失函数

在模型训练中，我们需要衡量价格预测与真实值之间的误差，通常会选取一个非负作为误差，且数值越小表示误差越小，一个常用的式子为

$\iota^i(w_1,w_2,b)=\frac{1}{2}(y^{*(i)}-y^{(i)})^2$

其中常数1/2使对平方项求导后的常数系数为1，这样在形式上稍微简单，其中这个式子的误差越小表示预测价格与真实价格越相近。

通常我们用训练数据集中所有样本误差的平均来衡量模型预测的质量，即

$\iota(w_1,w_2,b)=\frac{1}{n}\sum_{i=1}^{n}\iota^i(w_1,w_2,b)=\frac{1}{n}\sum_{i=1}^{n}\frac{1}{2}(x^i_1w_1+x^i_2w_2+b-y^i)^2$

在模型的训练中，我们希望找出一组模型参数，记为$ w^_1w^_2 b^*$，来使得训练样本平均损失最小：

$w^*_1,w*_2,b^*=argmin_{(w_1,w_2,b)}\iota(w_1,w_2,b)$

优化算法

我们通过小批量随机梯度下降法，来进行求出最优的$ w^_1w^_2 b^*$,使得目标函数最小，小批量随机梯度下降法具有特征在每次迭代中使用b个样本。Mini-Batch梯度下降算法与批量梯度下降算法类似，只不过它会选取B个样本来进行迭代，介于批量梯度下降算法与随机梯度下降算法之间，对于Mini-Batch而言B在

批量梯度下降算法：在每次迭代中使用所有样本

随机梯度下降算法：在每次迭代中使用一个样本

Mini-Batch梯度下降算法：在每次迭代中使用b个样本

图中是B为10的一个例子，Mini-batch在数据存取和求导的过程中使用向量化，进行并行计算，这样可以加快计算速度，而Mini-batch的一个缺点是需要确定参数B的大小。

对于上例中我们有算法

1
2
3

Repeat {

for i=1,i=b+1,i=2b+1,...n{

$w_1\leftarrow w_1-\frac{n}{|\beta|}(\sum_{i\in\beta}{}\frac{\partial\iota^{(i)}(w_1,w_2,b)}{\partial w_1})=w_1-\frac{n}{|\beta|}[\sum_{i\in\beta}{}x_1^{(i)}(x_1^{(i)}w_1+x_2^{(i)}w_2+b-y^{(i)})]$ $w_2\leftarrow w_2-\frac{n}{|\beta|}(\sum_{i\in\beta}{}\frac{\partial\iota^{(i)}(w_1,w_2,b)}{\partial w_2})=w_2-\frac{n}{|\beta|}[\sum_{i\in\beta}{}x_2^{(i)}(x_1^{(i)}w_1+x_2^{(i)}w_2+b-y^{(i)})]$ $b\leftarrow b-\frac{n}{|\beta|}(\sum_{i\in\beta}{}\frac{\partial\iota^{(i)}(w_1,w_2,b)}{\partial b})=b-\frac{n}{|\beta|}[\sum_{i\in\beta}{}(x_1^{(i)}w_1+x_2^{(i)}w_2+b-y^{(i)})]$

1
2

}
}

线性回归的表示方法

我们对训练数据集里的3个房屋样本(索引分别为1、2和3)逐一预测价格，将得到

$y^{*{(1)}}=x_1^{(1)}w_1+x_2^{(1)}w_2+b \\ y^{*{(2)}}=x_1^{(2)}w_1+x_2^{(2)}w_2+b \\ y^{*{(3)}}=x_1^{(3)}w_1+x_2^{(3)}w_2+b$

将上面3个等式转化成矢量计算，则有

$y^*=\left|\begin{matrix} y^{*(1)} \\ y^{*(2)}\\ y^{*(3)} \\ \end{matrix} \right| , X=\left|\begin{matrix} x_1^{(1)} \:\:x_2^{(1)}\\ x_1^{(2)} \:\:x_2^{(2)}\\ x_1^{(3)} \:\:x_2^{(3)} \\ \end{matrix} \right| , W=\left|\begin{matrix} w_1 \\ w_2\\ \end{matrix} \right|$

当数据样本数为n，特征数为d时，线性回归的矢量计算表达式为

其中模型输出$y^\in R^{n1} $，批量数据样本特征$ X \in R^{nd} $，权重$ W \in R^{d1} $，偏差$ b \in R $，批量数据样本标签$ y\in R^{n*1} $，设模型$ \theta=[w_1,w_2,b]^T$，我们重写损失函数为

$\iota(\theta)=\frac{1}{2n}(y^*-y)^T(y^*-y)$

小批量随机梯度下降可以改写为

$\theta\leftarrow \theta -\frac{n}{|\beta|}\sum_{i \in \beta}\bigtriangledown_{\theta}\iota^{(i)}(\theta)$ $\bigtriangledown_{\theta}\iota^{(i)}(\theta)=\left|\begin{matrix} \frac{\partial\iota^{(i)}(w_1,w_2,b)}{\partial w_1} \\ \frac{\partial\iota^{(i)}(w_1,w_2,b)}{\partial w_2} \\ \frac{\partial\iota^{(i)}(w_1,w_2,b)}{\partial b} \\ \end{matrix} \right|= \left|\begin{matrix} x_1^{(i)}(x_1^{(i)}w_1+x_2^{(i)}w_2+b-y^{(i)} \\ x_2^{(i)}(x_1^{(i)}w_1+x_2^{(i)}w_2+b-y^{(i)} \\ x_1^{(i)}w_1+x_2^{(i)}w_2+b-y^{(i)} \\ \end{matrix} \right|= \left|\begin{matrix} x_1^{(i)} \\ x_2^{(i)} \\ 1 \\ \end{matrix} \right|(y^{*(i)}-y^{(i)})$

线性回归从零开始实现

设我们训练数据集样本数为1000，输入个数(特征数)为2。给定随机生成的批量样本特征,我们使用线性回归模型真实权重和偏差以及一个随机噪声项来生成标签

$y=Xw+b+\epsilon$

其中噪声项服从均值为0、标准差为0.01的正态分布。噪声代表了数据集中无意义的干扰。

num_inputs=2 #特征项数
num_examples=1000 #样本数
true_w=[2,-3.4]
true_b=4.2
features=nd.random.normal(scale=1,shape(num_examples,num_inputs)) #生成1000*2个为1的标准差
labels=true_w[0]*features[:,0]+true_w[1]*features[;，1]+true_b
lables+=nd.random.normal(scale=0.01,shape=labels.shape) #

# 该函数返回batch_size(批量大小)个随机样本的特征和标签

def data_iter(batch_size,features,labels):
	num_examples=len(features) 
	indices=list(range(num_examples)) #生成样本数量个随机数
	random.shuffle(indices) #样本的读取顺序是随机的
	for i in range(0,num_examples,batch_size):
		j=nd.array(indices[i:min(i+batch_size,num_examples)])
		yield features.take(j),labels.take(j) #take函数根据索引返回对应元素

#初始化模型参数
#我们将权重初始化成均值为0、标准差为0.01的正态随机数，偏差则初始化成0
w=nd.random.normal(scale=0.01,shape=(num_inputs,1))
b=nd.zeros(shape=(1,))

#申请梯度
w.attach_grad()
b.attach_grad()

#定义函数 使用dot函数做矩阵乘法
def linreg(X,w,b):	
	return nd.dot(X,w)+b
#定义损失函数
#在实现中，我们需要把真实值y变成预测值y_hat的形状
def squared_loss(y_hat,y):
	return (y_hat-y.reshape(y.hat.shape))**2/2

#sgd函数实现了小批量随机梯度下降算法，通过不断迭代模型参数来优化损失函数。使用自动求梯度模块计算得来的#梯度是一个批量样本的梯度和，我们将它除以批量大小来得到平均值 
# params参数，lr学习率，batch_size批量大小
def sgd(params,lr,batch_size):
	for param in params:
		param[:]=param-lr*param.grad/batch_size
		
lr=0.03	#学习率
num_epochs=3 #迭代周期
net=linreg	
loss=squared_loss

for epoch in range(num_epochs):#训练模型一共需要num_epochs个迭代周期
    #在每一个迭代周期中，会使用训练数据集中所有样本一次(假设样本数能够被批量大小整除)。
    #x和y分别是小批量样本的特征和标签
    for X,y in data_iter(batch_size,features,labels):
        with autograd.record():
            l=loss(net(X,w,b),y) #l是有关小批量x和y的损失
        l.backward() #小批量的损失对模型参数求梯度
        sgd([w,b],lr,batch_size) #使用小批量随机梯度下降迭代模型参数
    train_l=loss(net(features,w,b),labels)
    print('epoch %d,loss %f' % (epoch+1,train_l.mean().asnumpy()))

通过上面的计算，我们得到结果(true_w为刚开始定义的值,w为我们通过计算得出的值)

true_w,w

true_b,b

通过以上结果我们可以知道，以上算法是通过优化目标模型来反向求得参数，使得求得的参数最接近原参数。

线性回归的简洁实现

from mxnet import autograd,nd

num_inputs=2
num_examples=1000
true_w=[2,3.4]
true_b=4.2
features=nd.random.normal(scale=1,shape=(num_examples,num_inputs))
labels=true_w[0]*features[:,0]+true_w[1]*features[:,1]+true_b
labels+=nd.random.normal(scale=0.01,shape=labels.shape)

from mxnet.gluon import data as gdata

batch_size=10
#将训练数据的特征和标签组合
dataset=gdata.ArrayDataset(features,labels)
#随机读取小批量
data_iter=gdata.DataLoader(dataset,batch_size,shuffle=True)


#定义模型
#Sequential为一个串联各个层的容器，可以看作一个画板
#Dense为全连接层，定义该层的输出为1
#Gluon中我们无须指定每一层输入的形状，如线性回归的输入个数，当模型得到数据时，如后面的执行net(X)时
#模型将自动推断出每一层的输入个数，如若是全相连的，通过层n推断n+1层的输入也是比较合理，且能实现的
from mxnet.gluon import nn
net=nn.Sequential()
net.add(nn.Dense(1))

#初始化模型参数
#从mxnet导入init模块，该模块提供了模型参数初始化的各种方法，通过init.Normal(sigma=0.01)指权重
#参数每个元素在初始化时随机采样于均值为0，标准差为0.01的正态分布，偏差参数默认会为0
from mxnet import init 
net.initialize(init.Normal(sigma=0.01))

#定义损失函数
from mxnet.gluon import loss as gloss
loss=gloss.L2Loss() #平方损失又称L2范数损失

#定义优化函数
#在导入Gluon之后，我们创建一个Trainer实例，并指定学习率为0.03的小批量随机梯度下降(sgd)为优化算法
#该优化算法用来迭代net实例所有通过add函数嵌套的层所包含的全部参数，这些参数可以通过collect_params
#函数获取
from mxnet import gluon
trainer=gluon.Trainer(net.collect_params(),'sgd',{'learning_rate':0.03})

#训练模型
#在使用Gluon训练模型时，我们通过调用Trainer实例的step函数来迭代模型参数，由于变量l是长度为
#batch_size的一维NDArray，执行l.backward()等价于执行l.sum().backward()。按照小批量随机
#梯度下降的定义，我们在step函数中指明批量大小，从而对批量中样本梯度求平均
num_epochs=3;
for epoch in range(1,num_epochs+1):
    for X,y in data_iter:
        with autograd.record():
             l=loss(net(X),y)
        l.backward()
        trainer.step(batch_size)
    l=loss(net(features),labels)
    print('epoch %d, loss:%f' % (epoch,l.mean().asnumpy()))

下面我们分别比较学到的模型参数与真实的模型参数，从而从net获得需要的层，并访问其权重和偏差。

1 2	dense=net[0] true_w,dense.weight.data()

1	true_b,dense.bias.data()

图像分类数据集(Fashion-MNIST)

#导包
%matplotlib inline
import d2lzh as d2l
from mxnet.gluon import data as gdata
import sys
import time

#获取数据集，从网上获取数据集，通过train来指定获取训练数据集或测试数据集
mnist_train=gdata.vision.FashionMNIST(train=True)
mnist_test=gdata.vision.FashionMNIST(train=False)

# mnist_train[0]同时返回feature与label,变量feature对应⾼和宽均为28像素的图像。每个像素的数值为0
#到255之间8位⽆符号整数（uint8)
feature,label=mnist_train[0]

#输出 ((28,28,1),numpy.uint8)
feature.shape,feature.dtype

#输出 (2,numpy.int32,dtype('int32')) label为2，后面通过函数把标签的数字转成文字标签
label,type(label),label.dtype

#将标签中的数字转换成文字标签
def get_fashion_mnist_labels(labels):
    text_labels=['t-shirt','trouser','pullover','dress','coat',
                 'sandal','shirt','sneaker','bag','ankle boot']
    return [text_labels[int(i)] for i in labels]
    
#下⾯定义⼀个可以在⼀⾏⾥画出多张图像和对应标签的函数
def show_fashion_mnist(images,labels):
    d2l.use_svg_display()
    _,figs=d2l.plt.subplots(1,len(images),figsize=(12,12))
    for f,img,lbl in zip(figs,images,labels):
        f.imshow(img.reshape((28,28)).asnumpy())
        f.set_title(lbl)
        f.axes.get_xaxis().set_visible(True)
        f.axes.get_yaxis().set_visible(True)

#我们看⼀下训练数据集中前9个样本的图像内容和⽂本标签
X,y=mnist_train[0:9]
show_fashion_mnist(X,get_fashion_mnist_labels(y))

softmax回归从零开始实现

%matplotlib inline
import d2lzh as d2l
from mxnet import autograd,nd

#设置批处理大小，且导入数据到训练集与测试集中
batch_size=256
train_iter,test_iter=d2l.load_data_fashion_mnist(batch_size)

#因为softmax回归模型是一个单层神经网络
#又由于输入向量的长度为28*28=784，该向量的每个元素对应图像中的每个像素，由于图像有十个类别，所以单层
#神经网络的输出层的输出个数为10
num_inputs=784
num_outputs=10
w=nd.random.normal(scale=0.01,shape=(num_inputs,num_outputs))
b=nd.zeros(num_outputs)
w.attach_grad()
b.attach_grad()

#在下⾯的函数中，矩阵X的⾏数是样本数，
#列数是输出个数。为了表达样本预测各个输出的概率， softmax运算会先通过exp函数对每个元素
#做指数运算，再对exp矩阵同⾏元素求和，最后令矩阵每⾏各元素与该⾏元素之和相除。这样⼀
#来，最终得到的矩阵每⾏元素和为1且⾮负。因此，该矩阵每⾏都是合法的概率分布。 softmax运
#算的输出矩阵中的任意⼀⾏元素代表了⼀个样本在各个输出类别上的预测概率
def softmax(X):
    X_exp=X.exp()
    partition=X_exp.sum(axis=1,keepdims=True)
    return X_exp/partition

1
2
3

#定义了softmax的回归模型
def net(X):
    return softmax(nd.dot(X.reshape((-1,num_inputs)),w)+b)

#损失函数
#对于样本i,使其他在正确标签的的时候值为1，其余的时候为0
#又因为每个样本只有一个标签，那么损失函数可能以进行简写
def cross_entropy(y_hat,y)
	return -nd.pick(y_hat,y).log()

上面的损失函数等价于 $-log_{y^{(i)}}y^{*(i)}$ ，其余部分后面实现

#定义两个数之间的准确率
#相等条件判别式(y_hat.argmax(axis=1) == y)是⼀个值为0（相等为假）或1（相等
#为真）的NDArray。由于标签类型为整数，我们先将变量y变换为浮点数再进⾏相等条件判断。
def accuracy(y_hat,y):
    return (y_hat.argmax(axis=1)==y.astype('float32')).mean().asscalar()

def evaluate_accuracy(data_iter,net):
    acc_sum,n=0.0,0
    for X,y in data_iter:
        y=y.astype('float32')
        acc_sum+=(net(X).argmax(axis=1)==y).sum().asscalar()
        n+=y.size
    return acc_sum/n

#训练模型
num_epochs,lr=5,0.1

def train_ch3(net,train_iter,test_iter,loss,num_epochs,batch_size,params=None,lr=None,trainer=None):
    for epoch in range(num_epochs):
        train_l_sum,train_acc_sum,n=0.0,0.0,0
        for X,y in train_iter: #train_iter 返回图像和标签
            with autograd.record(): 
                y_hat=net(X) #自己的y值
                l=loss(y_hat,y).sum()
            l.backward() #求导
            if trainer is None:
                d2l.sgd(params,lr,batch_size) #之前定义的小型梯度下降
            else:
                trainer.step(batch_size)
            y=y.astype('float32')
            train_l_sum+=l.asscalar()
            train_acc_sum+=(y_hat.argmax(axis=1)==y).sum().asscalar()
            n+=y.size
        test_acc=evaluate_accuracy(test_iter,net)
        print('epoch %d,loss %.4f,train acc %.3f,test acc %.3f'%(epoch+1,train_l_sum/n,train_acc_sum/n,test_acc))

1	train_ch3(net,train_iter,test_iter,cross_entropy,num_epochs,batch_size,[w,b],lr)

#给定⼀系列图像（第三⾏图像输出），我们⽐较⼀下它们的真实标签（第⼀⾏⽂本输出）和模型预测结果（第⼆⾏⽂
#本输出）
for X,y in test_iter:
    break
true_labels=d2l.get_fashion_mnist_labels(y.asnumpy())
pred_labels=d2l.get_fashion_mnist_labels(net(X).argmax(axis=1).asnumpy())
titels=[true+'\n'+pred for true,pred in zip(true_labels,pred_labels)]
d2l.show_fashion_mnist(X[0:9],titels[0:9])

softmax回归简洁实现

%matplotlib inline
import d2lzh as d2l
from mxnet import autograd,nd
from mxnet import gluon,init
from mxnet.gluon import loss as gloss,nn

#读取数据集
batch_size=256
train_iter,test_iter=d2l.load_data_fashion_mnist(batch_size)

#定义和初始化模型
#softmax回归的输出是一个全连接层，因此，我们添加一个输出个数为10的全连接层，我们使用均值0、标准差为#0.01的正态分布随机初始化模型的权重参数
net=nn.Sequential()
net.add(nn.Dense(10))
net.initialize(init.Normal(sigma=0.01))

#softmax和交叉熵损失函数
#Gluon提供了⼀个包括softmax运算和交叉熵损失计算的函数。它的数值稳定性更好。
loss=gloss.SoftmaxCrossEntropyLoss()

#定义优化算法
#使用学习率为0.1的小批量随机梯度下降作为优化算法
trainer=gluon.Trainer(net.collect_params(),'sgd',{'learning_rate':0.1})

#训练模型
num_epochs=5
d2l.train_ch3(net,train_iter,test_iter,loss,num_epochs,batch_size,None,None,trainer)

多层感知机

激活函数

多层感知机的从零开始实现

%matplotlib inline
import d2lzh as d2l
from mxnet import nd
from mxnet.gluon import loss as gloss

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

# Fashion-MNIST数据集中图像形状
#为28 × 28，类别数为10。本节中我们依然使⽤⻓度为28 × 28 = 784的向量表⽰每⼀张图像。因此，
#输⼊个数为784，输出个数为10。实验中，我们设超参数隐藏单元个数为256
num_inputs,num_outputs,num_hiddens=784,10,256
W1=nd.random.normal(scale=0.01,shape=(num_inputs,num_hiddens))
b1=nd.zeros(num_hiddens)
W2=nd.random.normal(scale=0.01,shape=(num_hiddens,num_outputs))
b2=nd.zeros(num_outputs)
params=[W1,b1,W2,b2]

多层感知机的简洁实现

import d2lzh as d2l
from mxnet import gluon,init
from mxnet.gluon import loss as gloss,nn

#和softmax回归唯⼀的不同在于，我们多加了⼀个全连接层作为隐藏层。它的隐藏单元个数为256，
#并使⽤ReLU函数作为激活函数
net=nn.Sequential()
net.add(nn.Dense(256,activation='relu'),nn.Dense(10))
net.initialize(init.Normal(sigma=0.01))

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

loss=gloss.SoftmaxCrossEntropyLoss()
trainer=gluon.Trainer(net.collect_params(),'sgd',{'learning_rate':0.5})
num_epochs=5
d2l.train_ch3(net,train_iter,test_iter,loss,num_epochs,batch_size,None,None,trainer)

欠拟合与过拟合

给定一个由标量数据特征x和对应的标题标签y组成的训练数据集，多项式函数拟合的目标是找一个K项多项式的函数

$y^*=b+\sum_{k=1}^{K}x^kw_k$

来近似，在上式中， $w_k$ 的模型的权重参数,b是偏差参数。

因为⾼阶多项式函数模型参数更多，模型函数的选择空间更⼤，所以⾼阶多项式函数⽐低阶多项式函数的复杂度更⾼。因此，⾼阶多项式函数⽐低阶多项式函数更容易在相同的训练数据集上得到更低的训练误差。给定训练数据集，模型复杂度和误差之间的关系通常如图3.4所⽰。给定训练数据集，如果模型的复杂度过低，很容易出现⽋拟合；如果模型复杂度过⾼，很容易出现过拟合。应对⽋拟合和过拟合的⼀个办法是针对数据集选择合适复杂度的模型。

影响⽋拟合和过拟合的另⼀个重要因素是训练数据集的⼤小。⼀般来说，如果训练数据集中样本数过少，特别是⽐模型参数数量（按元素计）更少时，过拟合更容易发⽣。此外，泛化误差不会随训练数据集⾥样本数量增加而增⼤。因此，在计算资源允许的范围之内，我们通常希望训练数据集⼤⼀些，特别是在模型复杂度较⾼时，如层数较多的深度学习模型。

%matplotlib inline
import d2lzh as d2l
from mxnet import autograd,gluon,nd
from mxnet.gluon import data as gdata,loss as gloss,nn

n_train,n_test,true_w,true_b=100,100,[1.2,-3.4,5.6],5
features=nd.random.normal(shape=(n_train+n_test,1))
#拼接,ploy_featuers=x,x^2,x^3
ploy_features=nd.concat(features,nd.power(features,2),nd.power(features,3))
#y=1.2x-3.4x^2+5.6x^3+5
labels=(true_w[0]*ploy_features[:,0]+true_w[1]*ploy_features[:,1]+true_w[2]*ploy_features[:,2]+true_b)
#y+=噪声项
labels+=nd.random.normal(scale=0.1,shape=labels.shape)

#作图函数
def semilogy(x_vals,y_vals,x_label,y_label,x2_vals=None,y2_vals=None,legend=None,figsize=(3.5,2.5)):
    d2l.set_figsize(figsize)
    d2l.plt.xlabel(x_label)
    d2l.plt.ylabel(y_label)
    d2l.plt.semilogy(x_vals,y_vals)
    if x2_vals and y2_vals:
       d2l.plt.semilogy(x2_vals,y2_vals,linestyle=':')
       d2l.plt.legend(legend)

num_epochs,loss=100,gloss.L2Loss()
def fit_and_plot(train_features,test_features,train_labels,test_labels):
    net=nn.Sequential()
    net.add(nn.Dense(1)) #单层神经网络，一个输出单元
    net.initialize() #初始化参数
    batch_size=min(10,train_labels.shape[0])
    train_iter=gdata.DataLoader(gdata.ArrayDataset(train_features,train_labels),batch_size,shuffle=True)
    trainer=gluon.Trainer(net.collect_params(),'sgd',{'learning_rate':0.01})
    train_ls,test_ls=[], []
    for _ in range(num_epochs):
        for X,y in train_iter:
            with autograd.record():
                l=loss(net(X),y)
            l.backward()
            trainer.step(batch_size)
        train_ls.append(loss(net(train_features),train_labels).mean().asscalar())
        test_ls.append(loss(net(test_features),test_labels).mean().asscalar())
    print('final epoch:train loss',train_ls[-1],'test loss',test_ls[-1])
    semilogy(range(1,num_epochs+1),train_ls,'epochs','loss',range(1,num_epochs+1),test_ls,['train','test'])
    print('weight:',net[0].weight.data().asnumpy(),'\nbias:',net[0].bias.data().asnumpy())

#三阶多项式函数拟合(正常)
#我们先使⽤与数据⽣成函数同阶的三阶多项式函数拟合。实验表明，这个模型的训练误差和在测
#试数据集的误差都较低。训练出的模型参数也接近真实值： w1 = 1:2; w2 = −3:4; w3 = 5:6; b = 5。
#ploy_features[:n_train,:]取前100个元素，ploy_features[n_train:,:]取后100个元素
fit_and_plot(ploy_features[:n_train,:],ploy_features[n_train:,:],labels[:n_train],labels[n_train:])

1
2
3

#线性函数拟合(欠拟合)
#这个地方，生成的函数是线性的，所以有欠拟合状态
fit_and_plot(features[:n_train,:],features[n_train:,:],labels[:n_train],labels[n_train:])

1 2	#训练样本不足(过拟合) fit_and_plot(ploy_features[0:2,:],ploy_features[n_train:,:],labels[0:2],labels[n_train:])

权重衰减-原理暂不解释

在上图中我们的更新公式为

$\theta_j:=\theta_j(1-a\frac{\lambda}{m})-a\frac{1}{m}(\sum_{i=1}^{m}(h_{\theta}(x^{(i)})-y^{(i)})x_j^{(i)})$ $1-a\frac{\lambda}{m}<1$$不大于1，这样进行逐步进行迭代。 <figure class="highlight clean"><table><tr><td class="gutter"><pre>1 2 3 4 5 </pre></td><td class="code"><pre>%matplotlib inline import d2lzh as d2l from mxnet import autograd,gluon,init,nd from mxnet.gluon import data as gdata,loss as gloss,nn </pre></td></tr></table></figure> <figure class="highlight routeros"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 </pre></td><td class="code"><pre>n_train,n_test,num_inputs=20,100,100 true_w,true_b=nd.ones((num_inputs,1))*0.01,0.05 features=nd.random.normal(shape=(n_train+n_test,num_inputs)) labels=nd.dot(features,true_w)+true_b labels+=nd.random.normal(scale=0.01,shape=labels.shape) train_features,test_features=features[:n_train,:],features[n_train:,:] train_labels,test_labels=labels[:n_train],labels[n_train:] </pre></td></tr></table></figure> ![image-20220410104348188](动手学深度学习总结/image-20220410104348188.png) <figure class="highlight css"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 </pre></td><td class="code"><pre>#初始化模型参数 def init_params(): w=nd.random.normal(scale=1,shape=(num_inputs,1)) b=nd.zeros(shape=(1,)) w.attach_grad() b.attach_grad() return [w,b] #定义l2范数惩罚项 def l2_penalty(w): return (w**2).sum()/2 #定义训练与测试 batch_size,num_epochs,lr=1,100,0.003 net,loss=d2l.linreg,d2l.squared_loss train_iter=gdata.DataLoader(gdata.ArrayDataset(train_features,train_labels),batch_size,shuffle=True) def fit_and_plot(lambd): w,b=init_params() train_ls,test_ls=[],[] for _ in range(num_epochs): for X,y in train_iter: with autograd.record(): l=loss(net(X,w,b),y)+lambd*l2_penalty(w) l.backward() d2l.sgd([w,b],lr,batch_size) train_ls.append(loss(net(train_features,w,b),train_labels).mean().asscalar()) test_ls.append(loss(net(test_features,w,b),test_labels).mean().asscalar()) d2l.semilogy(range(1,num_epochs+1),train_ls,'epochs','loss',range(1,num_epochs+1),test_ls,['train','test']) print('L2 norm of w:',w.norm().asscalar()) </pre></td></tr></table></figure> <figure class="highlight routeros"><table><tr><td class="gutter"><pre>1 2 </pre></td><td class="code"><pre>#观察过拟合 fit_and_plot(lambd=0) </pre></td></tr></table></figure> ![image-20220410104604559](动手学深度学习总结/image-20220410104604559.png) <figure class="highlight routeros"><table><tr><td class="gutter"><pre>1 2 </pre></td><td class="code"><pre>#使用权重衰减 fit_and_plot(lambd=3) </pre></td></tr></table></figure> ![image-20220410104636790](动手学深度学习总结/image-20220410104636790.png) ## 权重衰减简洁实现 <figure class="highlight routeros"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 </pre></td><td class="code"><pre>%matplotlib inline import d2lzh as d2l from mxnet import autograd,gluon,init,nd from mxnet.gluon import data as gdata,loss as gloss,nn n_train,n_test,num_inputs=20,100,100 true_w,true_b=nd.ones((num_inputs,1))*0.01,0.05 features=nd.random.normal(shape=(n_train+n_test,num_inputs)) labels=nd.dot(features,true_w)+true_b labels+=nd.random.normal(scale=0.01,shape=labels.shape) train_features,test_features=features[:n_train,:],features[n_train:,:] train_labels,test_labels=labels[:n_train],labels[n_train:] batch_size,num_epochs,lr=1,100,0.003 net,loss=d2l.linreg,d2l.squared_loss train_iter=gdata.DataLoader(gdata.ArrayDataset(train_features,train_labels),batch_size,shuffle=True) def fit_and_plot_gluon(wd): net=nn.Sequential() #nn.Dense #Dense实现了如下操作:output = activation(dot(input, weight) + bias)，其中activation是 #作为激活参数传递的元素激活函数，weight是由层创建的权重矩阵，bias是由层创建的偏差向量(仅在 #use_bias为True时适用)。 net.add(nn.Dense(1)) net.initialize(init.Normal(sigma=1)) #nn.collect_params #返回一个包含该Block及其所有子块Parameters的参数字典(默认)，也可以返回匹配某些给定正则表达式的 #select参数字典。 #wd也为函数的一个参数 #对权重参数衰减，权重名称一般以weight结尾 #不对偏差参数衰减，权重名称一般以bias结尾 trainer_w=gluon.Trainer(net.collect_params('.*weight'),'sgd',{'learning_rate':lr,'wd':wd}) trainer_b=gluon.Trainer(net.collect_params('.*bias'),'sgd',{'learning_rate':lr}) train_ls,test_ls=[],[] for _ in range(num_epochs): for X,y in train_iter: with autograd.record(): l=loss(net(X),y) l.backward() #更新权重和偏差 trainer_w.step(batch_size) #设置批量大小，设置梯度下降 trainer_b.step(batch_size) train_ls.append(loss(net(train_features),train_labels).mean().asscalar()) test_ls.append(loss(net(test_features),test_labels).mean().asscalar()) d2l.semilogy(range(1,num_epochs+1),train_ls,'epochs','loss',range(1,num_epochs+1),test_ls,['train','test']) print('L2 norm of w:',net[0].weight.data().norm().asscalar()) </pre></td></tr></table></figure> <figure class="highlight stylus"><table><tr><td class="gutter"><pre>1 </pre></td><td class="code"><pre>fit_and_plot_gluon(0) </pre></td></tr></table></figure> ![image-20220410115627382](动手学深度学习总结/image-20220410115627382.png) <figure class="highlight stylus"><table><tr><td class="gutter"><pre>1 </pre></td><td class="code"><pre>fit_and_plot_gluon(3) </pre></td></tr></table></figure> ![image-20220410115644377](动手学深度学习总结/image-20220410115644377.png) ## 数值稳定性和模型初始化 ![image-20220410123144883](动手学深度学习总结/image-20220410123144883.png) # 深度学习计算 ## 模型构造 **** ![image-20220410173714617](动手学深度学习总结/image-20220410173714617.png) <figure class="highlight css"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 </pre></td><td class="code"><pre>class FancyMLP(nn.Block): def __init__(self,**kwargs): super(FancyMLP,self).__init__(**kwargs) self.rand_weight=self.params.get_constant('rand_weight',nd.random.uniform(shape=(20,20))) self.dense=nn.Dense(20,activation='relu') def forward(self,x): # 使⽤创建的常数参数，以及NDArray的relu函数和dot函数 x=self.dense(x) # 复⽤全连接层。等价于两个全连接层共享参数 x=nd.relu(nd.dot(x,self.rand_weight.data())+1) # 控制流，这⾥我们需要调⽤asscalar函数来返回标量进⾏⽐较 x=self.dense(x) x while x.norm().asscalar()>1: x/=2 if x.norm().asscalar()<0.8: x*=10 return x.sum() net=FancyMLP() net.initialize() net(X) </pre></td></tr></table></figure> 其中神经模型为以下过程 ![构造复杂的模型](动手学深度学习总结/构造复杂的模型.png) 其中前后两个隐藏单元为同一层，共用同一参数ReLu(X) ## 模型参数的访问、初始化和共享 <figure class="highlight routeros"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 </pre></td><td class="code"><pre>from mxnet import init,nd from mxnet.gluon import nn net=nn.Sequential() net.add(nn.Dense(256,activation='relu')) net.add(nn.Dense(10)) net.initialize() X=nd.random.uniform(shape=(2,20)) Y=net(X) </pre></td></tr></table></figure> <figure class="highlight crmsh"><table><tr><td class="gutter"><pre>1 2 </pre></td><td class="code"><pre>#访问第一层的参数 net[0].params,type(net[0].params) </pre></td></tr></table></figure> ![image-20220410203825121](动手学深度学习总结/image-20220410203825121.png) <figure class="highlight haskell"><table><tr><td class="gutter"><pre>1 2 </pre></td><td class="code"><pre>#访问第一层权重的数据 net[0].weight.data() </pre></td></tr></table></figure> ![image-20220410203912239](动手学深度学习总结/image-20220410203912239.png) <figure class="highlight stylus"><table><tr><td class="gutter"><pre>1 2 </pre></td><td class="code"><pre>#第一层权重的梯度 net[0].weight.grad() </pre></td></tr></table></figure> ![image-20220410203953273](动手学深度学习总结/image-20220410203953273.png) <figure class="highlight haskell"><table><tr><td class="gutter"><pre>1 2 </pre></td><td class="code"><pre>#第二层权重数据 net[1].weight.data() </pre></td></tr></table></figure> ![image-20220410204035268](动手学深度学习总结/image-20220410204035268.png) <figure class="highlight 1c"><table><tr><td class="gutter"><pre>1 2 </pre></td><td class="code"><pre>#神经网络中所有参数 net.collect_params() </pre></td></tr></table></figure> ![image-20220410204113149](动手学深度学习总结/image-20220410204113149.png) <figure class="highlight 1c"><table><tr><td class="gutter"><pre>1 2 </pre></td><td class="code"><pre>#神经网络中所有权重(不含偏差) net.collect_params('.*weight') </pre></td></tr></table></figure> ![image-20220410204153597](动手学深度学习总结/image-20220410204153597.png) <figure class="highlight dos"><table><tr><td class="gutter"><pre>1 </pre></td><td class="code"><pre>net.collect_params() </pre></td></tr></table></figure> ![image-20220410221835680](动手学深度学习总结/image-20220410221835680.png) <figure class="highlight stylus"><table><tr><td class="gutter"><pre>1 2 3 4 </pre></td><td class="code"><pre>#模型的默认初始化⽅法：权重参数元素为[-0.07, 0.07]之间均匀分布的随机数，偏差参数则全为0。但我们经常需#要使⽤其他⽅法来初始化权重。 MXNet的init模块⾥提供了多种预设的初始化⽅法。在下⾯的例⼦中，我们将权重 #参数初始化成均值为0、标准差为0.01的正态分布随机数，并依然将偏差参数清零。 net.initialize(init=init.Normal(sigma=0.01),force_reinit=True) net[0].weight.data()[0] </pre></td></tr></table></figure> ![image-20220410221400528](动手学深度学习总结/image-20220410221400528.png) <figure class="highlight stylus"><table><tr><td class="gutter"><pre>1 2 </pre></td><td class="code"><pre>net.initialize(init=init.Normal(sigma=0.01),force_reinit=True) net[0].weight.data() </pre></td></tr></table></figure> ![image-20220410221926023](动手学深度学习总结/image-20220410221926023.png) <figure class="highlight stylus"><table><tr><td class="gutter"><pre>1 2 3 </pre></td><td class="code"><pre>#使用常数来初始化权重参数 net.initialize(init=init.Constant(1),force_reinit=True) net[0].weight.data() </pre></td></tr></table></figure> <figure class="highlight stylus"><table><tr><td class="gutter"><pre>1 2 3 </pre></td><td class="code"><pre>#我们对隐藏层的权重使用Xavier随机初始化方法 net[0].weight.initialize(init=init.Xavier(),force_reinit=True) net[0].weight.data()[0] </pre></td></tr></table></figure> ![image-20220410222224319](动手学深度学习总结/image-20220410222224319.png) ![image-20220410222411304](动手学深度学习总结/image-20220410222411304.png) ## 模型参数的延后初始化 ![image-20220410223649237](动手学深度学习总结/image-20220410223649237.png) ## 自定义层 ![image-20220411113908180](动手学深度学习总结/image-20220411113908180.png) # 卷积神经网络 ## 二维卷积层 ![image-20220411162009820](动手学深度学习总结/image-20220411162009820.png) <figure class="highlight apache"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 </pre></td><td class="code"><pre>from mxnet import autograd,nd from mxnet.gluon import nn #输入与核矩阵相乘 def corr2d(X,K): h,w=K.shape Y=nd.zeros((X.shape[0]-h+1,X.shape[1]-w+1)) for i in range(Y.shape[0]): for j in range(Y.shape[1]): Y[i,j]=(X[i:i+h,j:j+w]*K).sum() return Y X=nd.array([[0,1,2],[3,4,5],[6,7,8]]) K=nd.array([[0,1],[2,3]]) corr2d(X,K) </pre></td></tr></table></figure> ![image-20220411162449392](动手学深度学习总结/image-20220411162449392.png) <figure class="highlight ruby"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 </pre></td><td class="code"><pre>#加上偏差 class Conv2D(nn.Block): def __init__(self,kernel_size,**kwargs): super(Conv2D,self).__init__(**kwargs) self.weight=self.params.get('weight',shape=kernel_size) self.bias=self.params_get('bias',shape=(1,)) def forward(self,x): return corr2d(x,self.weight.data()+self.bias.data()) </pre></td></tr></table></figure> ![image-20220411162714775](动手学深度学习总结/image-20220411162714775.png) ### 通过数据学习核数组 <figure class="highlight apache"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 </pre></td><td class="code"><pre># 构造一个输出通道数为1，核数组形状是(1,2)的二维卷积层 conv2d=nn.Conv2D(1,kernel_size=(1,2)) conv2d.initialize() #二维卷积层使用4维输入输出，格式为(样本，通道，高，宽)，这里批量大小(批量中的样本数)和通道数均为1 X=X.reshape((1,1,6,8)) Y=Y.reshape((1,1,6,7)) for i in range(10): with autograd.record(): Y_hat=conv2d(X) l=(Y_hat-Y)**2 l.backward() conv2d.weight.data()[:]-=3e-2*conv2d.weight.grad() if (i+1)%2==0: print('batch %d, loss %.3f' %(i+1,l.sum().asscalar())) </pre></td></tr></table></figure> ![image-20220411163718012](动手学深度学习总结/image-20220411163718012.png) <figure class="highlight haskell"><table><tr><td class="gutter"><pre>1 </pre></td><td class="code"><pre>conv2d.weight.data().reshape((1,2)) </pre></td></tr></table></figure> ![image-20220411163737479](动手学深度学习总结/image-20220411163737479.png) 可以看出参数与图像中物体边缘检测中我们设置的参数[1,-1]接近，所以我们对核进行了参数迭代。 ![通过数据学习核数组](动手学深度学习总结/通过数据学习核数组.png) ## 填充与步幅 ![image-20220411173136493](动手学深度学习总结/image-20220411173136493.png) <figure class="highlight routeros"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 </pre></td><td class="code"><pre>from mxnet import nd from mxnet.gluon import nn #定义一个函数来计算卷积层。它初始化卷积层权重，并对输入和输出做相应的升维与降维 def comp_conv2d(conv2d,X): conv2d.initialize() #(1,1)代表批量大小和通道数均为1 X=X.reshape((1,1)+X.shape) Y=conv2d(X) return Y.reshape(Y.shape[2:])#排除不关心的前两维：批量与通道 #这里是两侧分别填充1行或列，所以在两侧一共填充2行与列 conv2d=nn.Conv2D(1,kernel_size=3,padding=1) conv2d X=nd.random.uniform(shape=(8,8)) comp_conv2d(conv2d,X).shape </pre></td></tr></table></figure> ![填充与步幅](动手学深度学习总结/填充与步幅.png) <figure class="highlight apache"><table><tr><td class="gutter"><pre>1 2 3 </pre></td><td class="code"><pre>#使用高为5，宽为3的卷积核，在高和宽两侧的填充数分别为2和1 conv2d=nn.Conv2D(1,kernel_size=(5,3),padding=(2,1)) comp_conv2d(conv2d,X).shape </pre></td></tr></table></figure> ![image-20220411174831149](动手学深度学习总结/image-20220411174831149.png) ![image-20220411174859742](动手学深度学习总结/image-20220411174859742.png) ## 多输入通道和多输出通道 ### 多输入通道 ![image-20220411180109484](动手学深度学习总结/image-20220411180109484.png) ![image-20220411180155152](动手学深度学习总结/image-20220411180155152.png) <figure class="highlight apache"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 </pre></td><td class="code"><pre>import d2lzh as d2l from mxnet import nd def corr2d_multi_in(X,K): return nd.add_n(*[d2l.corr2d(X,K) for X,K in zip(X,K)]) X=nd.array([[[0,1,2],[3,4,5],[6,7,8]],[[1,2,3],[4,5,6],[7,8,9]]]) K=nd.array([[[0,1],[2,3]],[[1,2],[3,4]]]) corr2d_multi_in(X,K) </pre></td></tr></table></figure> 通过在corr2d_multi_in函数里加*使得两个矩阵相加 ![image-20220411180307603](动手学深度学习总结/image-20220411180307603.png) ### 多输出通道 ![image-20220411180944244](动手学深度学习总结/image-20220411180944244.png) <figure class="highlight ruby"><table><tr><td class="gutter"><pre>1 2 3 </pre></td><td class="code"><pre>def corr2d_multi_in_out(X,K): #对K的第0维遍历，每次同输入X做互相关计算，所有结果使用stack函数合并在一起 return nd.stack(*[corr2d_multi_in(X,k) for k in K]) </pre></td></tr></table></figure> <figure class="highlight mathematica"><table><tr><td class="gutter"><pre>1 2 3 </pre></td><td class="code"><pre>#k+1等于K中的每个元素加一 K=nd.stack(K,K+1,K+2) K.shape </pre></td></tr></table></figure> ![image-20220411181123216](动手学深度学习总结/image-20220411181123216.png) 3表示样本数，2表示通道数，2表示高，2表示宽 <figure class="highlight stylus"><table><tr><td class="gutter"><pre>1 </pre></td><td class="code"><pre>corr2d_multi_in_out(X,K) </pre></td></tr></table></figure> ![image-20220411181233717](动手学深度学习总结/image-20220411181233717.png) ## 1x1卷积层 ![image-20220411203515169](动手学深度学习总结/image-20220411203515169.png) <figure class="highlight routeros"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 </pre></td><td class="code"><pre>def corr2d_multi_in_out_1x1(X,K): #c_i=3表三个输入,h高度,w宽度 c_i,h,w=X.shape #输出个数 c_o=K.shape[0] #3*9 X=X.reshape((c_i,h*w)) #2*3 K=K.reshape((c_o,c_i)) Y=nd.dot(K,X) return Y.reshape((c_o,h,w)) </pre></td></tr></table></figure> <figure class="highlight apache"><table><tr><td class="gutter"><pre>1 2 3 4 </pre></td><td class="code"><pre>#输入3*3*3 X=nd.random.uniform(shape=(3,3,3)) #核通道2，个数3，高和宽1*1 K=nd.random.uniform(shape=(2,3,1,1)) </pre></td></tr></table></figure> ![image-20220411203933318](动手学深度学习总结/image-20220411203933318.png) <figure class="highlight tp"><table><tr><td class="gutter"><pre>1 2 3 </pre></td><td class="code"><pre>Y1=corr2d_multi_in_out_1x1(X,K) Y2=corr2d_multi_in_out(X,K) (Y1-Y2).norm().asscalar()<1e-6 </pre></td></tr></table></figure> ![image-20220411204101977](动手学深度学习总结/image-20220411204101977.png) ## 池化层 ![image-20220411213253633](动手学深度学习总结/image-20220411213253633.png) <figure class="highlight apache"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 </pre></td><td class="code"><pre>from mxnet import nd from mxnet.gluon import nn def pool2d(X,pool_size,mode='max'): p_h,p_w=pool_size Y=nd.zeros((X.shape[0]-p_h+1,X.shape[1]-p_w+1)) for i in range(Y.shape[0]): for j in range(Y.shape[0]): if mode=='max': Y[i,j]=X[i:i+p_h,j:j+p_w].max() elif mode=='avg': Y[i,j]=X[i:i+p_h,j:j+p_w].mean() return Y X=nd.array([[0,1,2],[3,4,5],[6,7,8]]) pool2d(X,(2,2)) </pre></td></tr></table></figure> ![image-20220411211219896](动手学深度学习总结/image-20220411211219896.png) <figure class="highlight stylus"><table><tr><td class="gutter"><pre>1 </pre></td><td class="code"><pre>pool2d(X,(2,2),'avg') </pre></td></tr></table></figure> ![image-20220411211238878](动手学深度学习总结/image-20220411211238878.png) ![image-20220411213329939](动手学深度学习总结/image-20220411213329939.png) ## 卷积神经网络(LeNet) <figure class="highlight reasonml"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 </pre></td><td class="code"><pre>import d2lzh as d2l import mxnet as mx from mxnet import autograd,gluon,init,nd from mxnet.gluon import loss as gloss,nn import time net=nn.Sequential() # channels表过滤器的数量 net.add(nn.Conv2D(channels=6,kernel_size=5,activation='sigmoid'), nn.MaxPool2D(pool_size=2,strides=2), nn.Conv2D(channels=16,kernel_size=5,activation='sigmoid'), nn.MaxPool2D(pool_size=2,strides=2), # Dense会默认将(批量⼤⼩, 通道, ⾼, 宽)形状的输⼊转换成 # (批量⼤⼩, 通道 * ⾼ * 宽)形状的输⼊ nn.Dense(120,activation='sigmoid'), nn.Dense(84,activation='sigmoid'), nn.Dense(10)) X=nd.random.uniform(shape=(1,1,28,28)) net.initialize() for layer in net: X=layer(X) print(layer.name,'output shape:\t',X.shape) </pre></td></tr></table></figure> ![image-20220412105434810](动手学深度学习总结/image-20220412105434810.png) <figure class="highlight routeros"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 </pre></td><td class="code"><pre>batch_size=256 train_iter,test_iter=d2l.load_data_fashion_mnist(batch_size=batch_size) #尝试使用gpu def try_gpu(): try: ctx=mx.gpu() _=nd.zeros((1,),ctx=ctx) except mx.base.MXNetError: ctx=mx.cpu() return ctx ctx=try_gpu() ctx </pre></td></tr></table></figure> <figure class="highlight routeros"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 </pre></td><td class="code"><pre>#这个函数是通过样本X，经过卷积神经网络来得到生成的y_hat是否与y相同 def evaluate_accuracy(data_iter,net,ctx): acc_sum,n=nd.array([0],ctx=ctx),0 for X,y in data_iter: X,y=X.as_in_context(ctx),y.as_in_context(ctx).astype('float32') #net(X).argmax(axis=1)表示返回矩阵中每行最大元素的索引 #相等差别式(y_hat.argmax(axis=1)==y)是一个值为0(相等为假)或1(相等为真)的NDArray acc_sum+=(net(X).argmax(axis=1)==y).sum() n+=y.size return acc_sum.asscalar()/n </pre></td></tr></table></figure> <figure class="highlight css"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 </pre></td><td class="code"><pre>def train_ch5(net,train_iter,test_iter,batch_size,trainer,ctx,num_epochs): print('training on',ctx) loss=gloss.SoftmaxCrossEntropyLoss() for epoch in range(num_epochs): train_l_sum,train_acc_sum,n,start=0.0,0.0,0,time.time() for X,y in train_iter: X,y=X.as_in_context(ctx),y.as_in_context(ctx) with autograd.record(): y_hat=net(X) l=loss(y_hat,y).sum() l.backward() trainer.step(batch_size) y=y.astype('float32') train_l_sum+=l.asscalar() train_acc_sum+=(y_hat.argmax(axis=1)==y).sum().asscalar() n+=y.size test_acc=evaluate_accuracy(test_iter,net,ctx) print('epoch %d,loss %.4f, train acc %.3f,test acc %.3f,time %.1f sec' %(epoch+1,train_l_sum/n,train_acc_sum/n,test_acc,time.time()-start)) </pre></td></tr></table></figure> <figure class="highlight reasonml"><table><tr><td class="gutter"><pre>1 2 3 4 </pre></td><td class="code"><pre>lr,num_epochs=0.9,5 net.initialize(force_reinit=True,ctx=ctx,init=init.Xavier()) trainer=gluon.Trainer(net.collect_params(),'sgd',{'learning_rate':lr}) train_ch5(net,train_iter,test_iter,batch_size,trainer,ctx,num_epochs) </pre></td></tr></table></figure> ![image-20220412110156595](动手学深度学习总结/image-20220412110156595.png) ## 批量归一化 <figure class="highlight reasonml"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 </pre></td><td class="code"><pre>import d2lzh as d2l from mxnet import autograd,gluon,init,nd from mxnet.gluon import nn def batch_norm(X,gamma,beta,moving_mean,moving_var,eps,momentum): #通过autograd来判断当前模式是训练模式还是预测模式 if not autograd.is_training(): #如果是在预测模式下，直接使用传入的移动平均所得的均值与方差 X_hat=(X-moving_mean)/nd.sqrt(moving_var+eps) else: assert len(X.shape) in (2,4) #使用全连接层的情况，计算特征维上的均值与方差 if len(X.shape)==2: mean=X.mean(axis=0) var=((X-mean)**2).mean(axis=0) else: #使用二维卷积层的情况，计算通道维上(axis=1)的均值与方差，这里我们需要保持 #X的开关以便后面可以做广播运算 mean=X.mean(axis=(0,2,3),keepdims=True) var=((X-mean)**2).mean(axis=(0,2,3),keepdims=True) #训练模式下用当前的均值和方差做标准化 X_hat=(X-mean)/nd.sqrt(var+eps) #更新移动平均的均值与方差 moving_mean=momentum*moving_mean+(1.0-momentum)*mean moving_var=momentum*moving_var+(1.0-momentum)*var Y=gamma*X_hat+beta return Y,moving_mean,moving_var class BatchNorm(nn.Block): def __init__(self,num_features,num_dims,**kwargs): super(BatchNorm,self).__init__(**kwargs) if num_dims==2: shape=(1,num_features) else: shape=(1,num_features,1,1) #参与求梯度和迭代的拉伸和偏移参数，分别初始化为0和1 self.gamma=self.params.get('gamma',shape=shape,init=init.One()) self.beta=self.params.get('beta',shape=shape,init=init.Zero()) #不参与求梯度和迭代的变量，全在内存上初始化成0 self.moving_mean=nd.zeros(shape) self.moving_var=nd.zeros(shape) def forward(self,X): #如果X不在内存上，将moving_mean和moving_var复制到X所在的显存上 if self.moving_mean.context!=X.context: self.moving_mean=self.moving_mean.copyto(X.context) self.moving_var=self.moving_var.copyto(X.context) #保存更新过的moving_mean和moving_var Y,self.moving_mean,self.moving_var=batch_norm(X,self.gamma.data(), self.beta.data(),self.moving_mean,self.moving_var,eps=1e-5,momentum=0.9) return Y net=nn.Sequential() net.add(nn.Conv2D(6,kernel_size=5), BatchNorm(6,num_dims=4), nn.Activation('sigmoid'), nn.MaxPool2D(pool_size=2,strides=2), nn.Conv2D(16,kernel_size=4), BatchNorm(16,num_dims=4), nn.Activation('sigmoid'), nn.MaxPool2D(pool_size=2,strides=2), nn.Dense(120), BatchNorm(120,num_dims=2), nn.Activation('sigmoid'), nn.Dense(84), BatchNorm(84,num_dims=2), nn.Activation('sigmoid'), nn.Dense(10)) lr,num_epochs,batch_size,ctx=1.0,5,256,d2l.try_gpu() net.initialize(ctx=ctx,init=init.Xavier()) trainer=gluon.Trainer(net.collect_params(),'sgd',{'learning_rate':lr}) train_iter,test_iter=d2l.load_data_fashion_mnist(batch_size) d2l.train_ch5(net,train_iter,test_iter,batch_size,trainer,ctx,num_epochs) </pre></td></tr></table></figure> ![image-20220412162432934](动手学深度学习总结/image-20220412162432934.png) <figure class="highlight haskell"><table><tr><td class="gutter"><pre>1 2 </pre></td><td class="code"><pre>#查看第一批量归化一层学习到的拉伸参数gamma和偏移参数beta net[1].gamma.data().reshape((-1,)),net[1].beta.data().reshape((-1,)) </pre></td></tr></table></figure> ![image-20220412162614282](动手学深度学习总结/image-20220412162614282.png) ## 批量归一化的简洁实现 <figure class="highlight reasonml"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 </pre></td><td class="code"><pre> #使用gluon的批量归一化 net=nn.Sequential() net.add(nn.Conv2D(6,kernel_size=5), nn.BatchNorm(), nn.Activation('sigmoid'), nn.MaxPool2D(pool_size=2,strides=2), nn.Conv2D(16,kernel_size=5), nn.BatchNorm(), nn.Activation('sigmoid'), nn.MaxPool2D(pool_size=2,strides=2), nn.Dense(120), nn.BatchNorm(), nn.Activation('sigmoid'), nn.Dense(84), nn.BatchNorm(), nn.Activation('sigmoid'), nn.Dense(10) ) net.initialize(ctx=ctx,init=init.Xavier()) trainer=gluon.Trainer(net.collect_params(),'sgd',{'learning_rate':lr}) d2l.train_ch5(net,train_iter,test_iter,batch_size,trainer,ctx,num_epochs) </pre></td></tr></table></figure> ![image-20220412165145598](动手学深度学习总结/image-20220412165145598.png) ## 残差网络 ![image-20220412180722522](动手学深度学习总结/image-20220412180722522.png) <figure class="highlight haskell"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 </pre></td><td class="code"><pre>import d2lzh as d2l from mxnet import gluon,init,nd from mxnet.gluon import nn class Residual(nn.Block): def __init__(self,num_channels,use_1x1conv=False,strides=1,**kwargs): super(Residual,self).__init__(**kwargs) self.conv1=nn.Conv2D(num_channels,kernel_size=3,padding=1,strides=strides) self.conv2=nn.Conv2D(num_channels,kernel_size=3,padding=1) if use_1x1conv: self.conv3=nn.Conv2D(num_channels,kernel_size=1,strides=strides) else: self.conv3=None self.bn1=nn.BatchNorm() self.bn2=nn.BatchNorm() def forward(self,X): Y=nd.relu(self.bn1(self.conv1(X))) Y=self.bn2(self.conv2(Y)) if self.conv3: X=self.conv3(X) return nd.relu(Y+X) </pre></td></tr></table></figure> 可以通过调用跳过第三层卷积层。 <figure class="highlight stylus"><table><tr><td class="gutter"><pre>1 2 3 4 </pre></td><td class="code"><pre>blk=Residual(3) blk.initialize() X=nd.random.uniform(shape=(4,3,6,6)) blk(X).shape </pre></td></tr></table></figure> ![image-20220412180853217](动手学深度学习总结/image-20220412180853217.png) <figure class="highlight stylus"><table><tr><td class="gutter"><pre>1 2 3 </pre></td><td class="code"><pre>blk=Residual(6,use_1x1conv=True,strides=2) blk.initialize() blk(X).shape </pre></td></tr></table></figure> ![image-20220412180949437](动手学深度学习总结/image-20220412180949437.png) ### ResNet模型 ![image-20220412181057419](动手学深度学习总结/image-20220412181057419.png) ![image-20220412190440555](动手学深度学习总结/image-20220412190440555.png) # 循环神经网络假设有一段长度为T的文本中的词依次为$$w_1,w_2,...,w_t$$，那么在离散的时间序列中，$$w_t(1\leq t\leq T)$$可看作在时间步T的输出或标签，即有语言模型$

P(w_1,w_2,…,w_t)

$假设序列$$w_1,w_2,...,w_t$$中的每个词依次生成的，我们有$

P(w_1,w_2,…,w_t)=\prod_{t=1}^Tp(w_t|w_1,…,w_{t-1})

$其中$$p(w_2|w_1)$$可以计算为$$w_1$$和$$w_2$$两词相邻的频率与$$w_1$$词频的比值，因为该比值即$$p(w_1,w_2)$$与$$p(w_1)$$之比 ![image-20220415124314823](动手学深度学习总结/image-20220415124314823.png) 对这部分我们有公式 ![image-20220415124353842](动手学深度学习总结/image-20220415124353842.png) $$H_{t-1}$$为上一层的隐藏状态，所以这表示该层的隐藏状态与上一层的隐藏状态有关，所以会导致上一层的隐藏状态会影响这一层的隐藏状态，而输出层又为 ![image-20220415124442889](动手学深度学习总结/image-20220415124442889.png) ## 语言模型数据集 <figure class="highlight python"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 </pre></td><td class="code"><pre>from mxnet import nd import random import zipfile #读取数据集 with zipfile.ZipFile('data/jaychou_lyrics.txt.zip') as zin: with zin.open('jaychou_lyrics.txt') as f: corpus_chars=f.read().decode('utf-8') corpus_chars[:40] #读取前40个字符 </pre></td></tr></table></figure> ![image-20220414214551904](动手学深度学习总结/image-20220414214551904.png) <figure class="highlight ini"><table><tr><td class="gutter"><pre>1 2 3 </pre></td><td class="code"><pre>#把换行符替换成空格，使用前1万个字符来训练模型 corpus_chars=corpus_chars.replace('\n',' ').replace('\r',' ') corpus_chars=corpus_chars[0:10000] </pre></td></tr></table></figure> <figure class="highlight routeros"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 </pre></td><td class="code"><pre>#建立字符索引，将字符映射成数字 idx_to_char=list(set(corpus_chars)) #字符组映射成数字组 char_to_idx=dict([(char,i)for i,char in enumerate(idx_to_char)]) vocab_size=len(char_to_idx) vocab_size #分别打印出字符组与所对应的数字组 corpus_indices=[char_to_idx[char] for char in corpus_chars] sample=corpus_indices[:20] print('chars:',''.join([idx_to_char[idx] for idx in sample])) print('indices:',sample) </pre></td></tr></table></figure> ![image-20220414215208400](动手学深度学习总结/image-20220414215208400.png) <figure class="highlight python"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 </pre></td><td class="code"><pre>#随机采样 #batch_size指每个小批量的样本数，num_steps为每个样本包含的时间步数 def data_iter_random(corpus_indices,batch_size,num_steps,ctx=None): #减1是因为输出的索引是相应输入的索引加1 num_examples=(len(corpus_indices)-1)//num_steps #迭代数=样本数/批量大小 epoch_size=num_examples//batch_size example_indices=list(range(num_examples)) random.shuffle(example_indices) #返回从pos开始的长为num_steps的序列 def _data(pos): return corpus_indices[pos:pos+num_steps] for i in range(epoch_size): i=i*batch_size batch_indices=example_indices[i:i+batch_size] X=[_data(j*num_steps) for j in batch_indices] Y=[_data(j*num_steps+1) for j in batch_indices] yield nd.array(X,ctx),nd.array(Y,ctx) </pre></td></tr></table></figure> <figure class="highlight routeros"><table><tr><td class="gutter"><pre>1 2 3 4 </pre></td><td class="code"><pre>#my_seq为人工序列，batch_size为批量大小，num_steps为时间步数 my_seq=list(range(30)) for X,Y in data_iter_random(my_seq,batch_size=2,num_steps=6): print('X: ',X,'\nY:',Y,'\n') </pre></td></tr></table></figure> ![image-20220414215323211](动手学深度学习总结/image-20220414215323211.png) <figure class="highlight elixir"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 </pre></td><td class="code"><pre>#相邻采样 def data_iter_consecutive(corpus_indices,batch_size,num_steps,ctx=None): corpus_indices=nd.array(corpus_indices,ctx=ctx) data_len=len(corpus_indices) batch_len=data_len//batch_size indices=corpus_indices[0:batch_size*batch_len].reshape((batch_size,batch_len)) epoch_size=(batch_len-1)//num_steps for i in range(epoch_size): i=i*num_steps X=indices[:,i:i+num_steps] Y=indices[:,i+1:i+num_steps+1] yield X,Y </pre></td></tr></table></figure> <figure class="highlight routeros"><table><tr><td class="gutter"><pre>1 2 </pre></td><td class="code"><pre>for X,Y in data_iter_consecutive(my_seq,batch_size=2,num_steps=6): print('X: ',X,'\nY:',Y,'\n') </pre></td></tr></table></figure> ![image-20220414215520491](动手学深度学习总结/image-20220414215520491.png) ## 循环神经网络的从零开始实现 <figure class="highlight elm"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 </pre></td><td class="code"><pre>import d2lzh as d2l import math from mxnet import autograd,nd from mxnet.gluon import loss as gloss import time (corpus_indices,char_to_idx,idx_to_char,vocab_size)=d2l.load_data_jay_lyrics() </pre></td></tr></table></figure> <figure class="highlight apache"><table><tr><td class="gutter"><pre>1 2 </pre></td><td class="code"><pre>#这是one-hot向量 nd.one_hot(nd.array([0,2]),vocab_size) </pre></td></tr></table></figure> ![image-20220414215644013](动手学深度学习总结/image-20220414215644013.png) <figure class="highlight ruby"><table><tr><td class="gutter"><pre>1 2 3 </pre></td><td class="code"><pre>#one-hot向量定义 def to_onehot(X,size): return [nd.one_hot(x,size) for x in X.T] </pre></td></tr></table></figure> <figure class="highlight apache"><table><tr><td class="gutter"><pre>1 2 </pre></td><td class="code"><pre>X=nd.arange(10).reshape((2,5)) X </pre></td></tr></table></figure> ![image-20220414215810664](动手学深度学习总结/image-20220414215810664.png) <figure class="highlight reasonml"><table><tr><td class="gutter"><pre>1 2 </pre></td><td class="code"><pre>inputs=to_onehot(X,vocab_size) inputs </pre></td></tr></table></figure> ![image-20220414215828076](动手学深度学习总结/image-20220414215828076.png) <figure class="highlight stylus"><table><tr><td class="gutter"><pre>1 </pre></td><td class="code"><pre>len(inputs),inputs[0].shape </pre></td></tr></table></figure> ![image-20220414215844220](动手学深度学习总结/image-20220414215844220.png) <figure class="highlight routeros"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 </pre></td><td class="code"><pre>#初始化模型参数 num_inputs,num_hiddens,num_outputs=vocab_size,256,vocab_size ctx=d2l.try_gpu() print('will use',ctx) #初始化模型参数 def get_params(): def _one(shape): return nd.random.normal(scale=0.01,shape=shape,ctx=ctx) #隐藏层参数 W_xh=_one((num_inputs,num_hiddens)) W_hh=_one((num_hiddens,num_hiddens)) b_h=nd.zeros(num_hiddens,ctx=ctx) #输出层参数 W_hq=_one((num_hiddens,num_outputs)) b_q=nd.zeros(num_outputs,ctx=ctx) #附上模型 params=[W_xh,W_hh,b_h,W_hq,b_q] for param in params: param.attach_grad() return params </pre></td></tr></table></figure> <figure class="highlight ruby"><table><tr><td class="gutter"><pre>1 2 3 </pre></td><td class="code"><pre>#初始化rnn模型状态 def init_rnn_state(batch_size,num_hiddens,ctx): return (nd.zeros(shape=(batch_size,num_hiddens),ctx=ctx),) </pre></td></tr></table></figure> <figure class="highlight pf"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 </pre></td><td class="code"><pre>def rnn(inputs,state,params): W_xh,W_hh,b_h,W_hq,b_q=params H,=state outputs=[] for X in inputs: H=nd.tanh(nd.dot(X,W_xh)+nd.dot(H,W_hh)+b_h) Y=nd.dot(H,W_hq)+b_q outputs.append(Y) return outputs,(H,) </pre></td></tr></table></figure> ![循环神经网络rnn公式](动手学深度学习总结/循环神经网络rnn公式.png) <figure class="highlight stylus"><table><tr><td class="gutter"><pre>1 2 3 4 5 </pre></td><td class="code"><pre>state=init_rnn_state(X.shape[0],num_hiddens,ctx) inputs=to_onehot(X.as_in_context(ctx),vocab_size) params=get_params() outputs,state_new=rnn(inputs,state,params) len(outputs),outputs[0].shape,state_new[0].shape </pre></td></tr></table></figure> ![image-20220414220338235](动手学深度学习总结/image-20220414220338235.png) <figure class="highlight reasonml"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 </pre></td><td class="code"><pre>#本函数基于前缀prefix(含有数个字符的字符串)来预测接下来的num_chars个字符。 def predict_rnn(prefix,num_chars,rnn,params,init_run_state,num_hiddens,vocab_size,ctx,idx_to_char,char_to_idx): state=init_run_state(1,num_hiddens,ctx) output=[char_to_idx[prefix[0]]] for t in range(num_chars+len(prefix)-1): #将上一时间步的输出当作当前时间步的输入，第一次输入为output[-1]为output[0]，第二次为上次 #时间步 X=to_onehot(nd.array([output[-1]],ctx=ctx),vocab_size) #计算输出和更新隐藏状态 (Y,state)=rnn(X,state,params) #下一个时间步的输入是prefix里的字符或者当前的最佳预测字符 if t<len(prefix)-1: output.append(char_to_idx[prefix[t+1]]) else: output.append(int(Y[0].argmax(axis=1).asscalar()))#取概率为最大的那一个 return ''.join([idx_to_char[i] for i in output]) </pre></td></tr></table></figure> <figure class="highlight reasonml"><table><tr><td class="gutter"><pre>1 </pre></td><td class="code"><pre>predict_rnn('分开',10,rnn,params,init_rnn_state,num_hiddens,vocab_size,ctx,idx_to_char,char_to_idx) </pre></td></tr></table></figure> ![image-20220414222335439](动手学深度学习总结/image-20220414222335439.png) <figure class="highlight livecodeserver"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 </pre></td><td class="code"><pre>#裁剪梯度 def grad_clipping(params,theta,ctx): norm=nd.array([0],ctx) for param in params: norm+=(param.grad**2).sum() norm=norm.sqrt().asscalar() if norm>theta: for param in params: param.grad[:]*=theta/norm </pre></td></tr></table></figure> ![image-20220414222559582](动手学深度学习总结/image-20220414222559582.png) <figure class="highlight routeros"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 </pre></td><td class="code"><pre>#定义模型训练函数 def train_and_predict_rnn(rnn,get_params,init_rnn_state,num_hiddens,vocab_size,ctx,corpus_indices,idx_to_char,char_to_idx, is_random_iter,num_epochs,num_steps,lr,clipping_theta,batch_size,pred_period,pred_len,prefixes): if is_random_iter: data_iter_fn=d2l.data_iter_random else: data_iter_fn=d2l.data_iter_consecutive params=get_params() loss=gloss.SoftmaxCrossEntropyLoss() # print(num_epochs) for epoch in range(num_epochs): # print(epoch) if not is_random_iter: state=init_rnn_state(batch_size,num_hiddens,ctx) l_sum,n,start=0.0,0,time.time() data_iter=data_iter_fn(corpus_indices,batch_size,num_steps,ctx) for X,Y in data_iter: if is_random_iter: state=init_rnn_state(batch_size,num_hiddens,ctx) else: for s in state: s.detach() with autograd.record(): inputs=to_onehot(X,vocab_size) (outputs,state)=rnn(inputs,state,params) outputs=nd.concat(*outputs,dim=0) y=Y.T.reshape((-1,)) l=loss(outputs,y).mean() l.backward() grad_clipping(params,clipping_theta,ctx) d2l.sgd(params,lr,1) l_sum+=l.asscalar()*y.size n+=y.size if (epoch+1)%pred_period==0: print('epoch %d,perplexity %f,time %.2f sec'%(epoch+1,math.exp(l_sum/n),time.time()-start)) for prefix in prefixes: print('-',predict_rnn(prefix,pred_len,rnn,params,init_rnn_state,num_hiddens,vocab_size,ctx, idx_to_char,char_to_idx)) </pre></td></tr></table></figure> <figure class="highlight apache"><table><tr><td class="gutter"><pre>1 2 3 4 5 6 </pre></td><td class="code"><pre>num_epochs,num_steps,batch_size,lr,clipping_theta=250,35,32,1e2,1e-2 pred_period,pred_len,prefixes=50,50,['分开','不分开'] train_and_predict_rnn(rnn,get_params,init_rnn_state,num_hiddens,vocab_size,ctx,corpus_indices,idx_to_char, char_to_idx,True,num_epochs,num_steps,lr,clipping_theta,batch_size,pred_period,pred_len, prefixes) </pre></td></tr></table></figure> ![image-20220414222728131](动手学深度学习总结/image-20220414222728131.png) ## 门控循环单元(GRU) 门控循环单元结构 ![image-20220415130545022](动手学深度学习总结/image-20220415130545022.png) 候选隐藏单元 ![image-20220415130715939](动手学深度学习总结/image-20220415130715939.png) 可以看出这个地方是由重置门来控制$$H_{t-1}$$，当重置门为0时，表示上一时间步的隐藏状态$$H_{t-1}$$不加入该时间步中，即上一时间步不影响这一时间步隐藏单元$$\tilde{H_t}$$的生成，当重置门为1时，表示上一时间步的隐藏状态$$H_{t-1}$$会影响该时间步隐藏单元$$\tilde{H_t}$$的的生成。 ![image-20220415131115611](动手学深度学习总结/image-20220415131115611.png) 可以看到我们有t时刻的隐藏状态公式 ![image-20220415131637947](动手学深度学习总结/image-20220415131637947.png) 这表示若更新门当从t-1到t时之间近似为1，表示在时间步t-1到t之间的输入信息几乎没有流入时间步t的隐藏状态$$H_t$$，这表示我从所状态$$H_{t-1}$$隐藏状态，经过t时间步的单元时没有怎么改变，并且可以以$$H_{t}$$的状态输入到时刻t+1处，这可以保证时间序列之间的长依赖。 **重置门有助力捕捉时间序列里短期的依赖关系，从t-1到t时刻** **更新门有助于捕捉时间序列里长期的依赖关系，可以通过更新门把状态从更加长时间的依赖** ![GRUpng](动手学深度学习总结/GRUpng.png)$

(Y^{})^{}=H_tW_{hq}+b

王权个人博客

动手学深度学习总结