动手学深度学习_1

1.线性回归

线性回归输出是一个连续值，因此适用于回归问题。回归问题在实际中很常见，如预测房屋价格、气温、销售额等连续值的问题。

1.1线性回归

1.1.1 数据集

我们通常收集一系列的真实数据，例如多栋房屋的真实售出价格和它们对应的面积和房龄。我们希望在这个数据上面寻找模型参数来使模型的预测价格与真实价格的误差最小。在机器学习术语里，该数据集被称为训练数据集（training data set）或训练集（training set），一栋房屋被称为一个样本（sample），其真实售出价格叫作标签（label），用来预测标签的两个因素叫作特征（feature）。特征用来表征样本的特点。

1.1.2 模型

为了简单起见，这里我们假设价格只取决于房屋状况的两个因素，即面积（平方米）和房龄（年）。接下来我们希望探索价格与这两个因素的具体关系。线性回归假设输出与各个输入之间是线性关系:

1.1.3 损失函数

在模型训练中，我们需要衡量价格预测值与真实值之间的误差。通常我们会选取一个非负数作为误差，且数值越小表示误差越小。一个常用的选择是平方函数。 它在评估索引为 i 的样本误差的表达式为

1.1.4 优化函数 - 随机梯度下降

当模型和损失函数形式较为简单时，上面的误差最小化问题的解可以直接用公式表达出来。这类解叫作解析解（analytical solution）。本节使用的线性回归和平方误差刚好属于这个范畴。然而，大多数深度学习模型并没有解析解，只能通过优化算法有限次迭代模型参数来尽可能降低损失函数的值。这类解叫作数值解（numerical solution）。

在求数值解的优化算法中，小批量随机梯度下降（mini-batch stochastic gradient descent）在深度学习中被广泛使用。它的算法很简单：先选取一组模型参数的初始值，如随机选取；接下来对参数进行多次迭代，使每次迭代都可能降低损失函数的值。在每次迭代中，先随机均匀采样一个由固定数目训练数据样本所组成的小批量（mini-batch） B ，然后求小批量中数据样本的平均损失有关模型参数的导数（梯度），最后用此结果与预先设定的一个正数的乘积作为模型参数在本次迭代的减小量。

学习率: η 代表在每次优化中，能够学习的步长的大小
批量大小: B 是小批量计算中的批量大小batch size

总结一下，优化函数的有以下两个步骤：

(i)初始化模型参数，一般来说使用随机初始化；
(ii)我们在数据上迭代多次，通过在负梯度方向移动参数来更新每个参数。

1.2 代码实现

1.2.1 线性回归从零开始版

导入所需包

构建数据集

查看生成数据与标签的关系

读取数据

初始化模型参数

定义模型

定义损失函数_均方误差

定义随机梯度_最小批量梯度下降

训练模型

1.2.2 线性回归pytorch版

# 导入包
import torch
import torch.utils.data as Data
from torch import nn
from torch.nn import init
import torch.optim as optim
import numpy as np 
torch.manual_seed(1)
print(torch.__version__)
torch.set_default_tensor_type('torch.FloatTensor')

# 生成数据
num_inputs=2
num_examples=1000
true_w=[2,-3.14]
true_b=4.2
featues=torch.tensor(np.random.normal(0,1,(num_examples,num_inputs)),dtype=torch.float)
labels=true_w[0]*features[:,0]+true_w[1]*features[:,1]+true_b
labels+=torch.tensor(np.random.normal(0,0.01,size=labels.size()),dtype=torch.float)

# 读取数据
batch_size=10
dataset=Data.TensorDataset(features,labels)

data_iter=Data.DataLoader(
   dataset=dataset,
   batch_size=batch_size,
   shuffle=True,
   num_workers=2
)
# 定义网络
class LinearNet(nn.Module):
   def __init__(self,n_feature):
       super(LinearNet,self).__init__()
       self.linear=nn.Linear(n_feature,1)
   def forward(self,x):
       y=self.linear(x)
       return y
net=LinearNet(num_inputs)
#print(net)

# 初始化模型参数

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)

# 定义损失函数与优化函数
loss=nn.MSELoss()
optimizer=optim.SGD(net.parameters(),lr=0.03)

# 训练
num_epochs=10
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()
       l.backward()
       optimizer.step()
   print('epoch %d, loss: %f' % (epoch, l.item()))

从零开始的实现能够更好的理解模型和神经网络底层的原理。使用pytorch的简洁实现能够更加快速地完成模型的设计与实现。

2.softmax与分类模型

2.1 softmax的基本概念

• 分类问题
  一个简单的图像分类问题，输入图像的高和宽均为2像素，色彩为灰度。
  图像中的4像素分别记为$x_1, x_2, x_3, x_4$x1​,x2​,x3​,x4​。
  假设真实标签为狗、猫或者鸡，这些标签对应的离散值为$y_1, y_2, y_3$y1​,y2​,y3​。
  我们通常使用离散的数值来表示类别，例如$y_1=1, y_2=2, y_3=3$y1​=1,y2​=2,y3​=3。

• 权重矢量
  $\begin{aligned} o_1 &= x_1 w_{11} + x_2 w_{21} + x_3 w_{31} + x_4 w_{41} + b_1 \end{aligned}$o1​​=x1​w11​+x2​w21​+x3​w31​+x4​w41​+b1​​

$\begin{aligned} o_2 &= x_1 w_{12} + x_2 w_{22} + x_3 w_{32} + x_4 w_{42} + b_2 \end{aligned}$o2​​=x1​w12​+x2​w22​+x3​w32​+x4​w42​+b2​​

$\begin{aligned} o_3 &= x_1 w_{13} + x_2 w_{23} + x_3 w_{33} + x_4 w_{43} + b_3 \end{aligned}$o3​​=x1​w13​+x2​w23​+x3​w33​+x4​w43​+b3​​

• 神经网络图
  下图用神经网络图描绘了上面的计算。softmax回归同线性回归一样，也是一个单层神经网络。由于每个输出$o_1, o_2, o_3$o1​,o2​,o3​的计算都要依赖于所有的输入$x_1, x_2, x_3, x_4$x1​,x2​,x3​,x4​，softmax回归的输出层也是一个全连接层。

$\begin{aligned}softmax回归是一个单层神经网络\end{aligned}$softmax回归是一个单层神经网络​

既然分类问题需要得到离散的预测输出，一个简单的办法是将输出值$o_i$oi​当作预测类别是$i$i的置信度，并将值最大的输出所对应的类作为预测输出，即输出 $\underset{i}{\arg\max} o_i$iargmax​oi​。例如，如果$o_1,o_2,o_3$o1​,o2​,o3​分别为$0.1,10,0.1$0.1,10,0.1，由于$o_2$o2​最大，那么预测类别为2，其代表猫。

• 输出问题
  直接使用输出层的输出有两个问题：
  1. 一方面，由于输出层的输出值的范围不确定，我们难以直观上判断这些值的意义。例如，刚才举的例子中的输出值10表示“很置信”图像类别为猫，因为该输出值是其他两类的输出值的100倍。但如果$o_1=o_3=10^3$o1​=o3​=103，那么输出值10却又表示图像类别为猫的概率很低。
  2. 另一方面，由于真实标签是离散值，这些离散值与不确定范围的输出值之间的误差难以衡量。

softmax运算符（softmax operator）解决了以上两个问题。它通过下式将输出值变换成值为正且和为1的概率分布：

$\hat{y}_1, \hat{y}_2, \hat{y}_3 = \text{softmax}(o_1, o_2, o_3)$y^​1​,y^​2​,y^​3​=softmax(o1​,o2​,o3​)

其中

$\hat{y}1 = \frac{ \exp(o_1)}{\sum_{i=1}^3 \exp(o_i)},\quad \hat{y}2 = \frac{ \exp(o_2)}{\sum_{i=1}^3 \exp(o_i)},\quad \hat{y}3 = \frac{ \exp(o_3)}{\sum_{i=1}^3 \exp(o_i)}.$y^​1=∑i=13​exp(oi​)exp(o1​)​,y^​2=∑i=13​exp(oi​)exp(o2​)​,y^​3=∑i=13​exp(oi​)exp(o3​)​.

容易看出$\hat{y}_1 + \hat{y}_2 + \hat{y}_3 = 1$y^​1​+y^​2​+y^​3​=1且$0 \leq \hat{y}_1, \hat{y}_2, \hat{y}_3 \leq 1$0≤y^​1​,y^​2​,y^​3​≤1，因此$\hat{y}_1, \hat{y}_2, \hat{y}_3$y^​1​,y^​2​,y^​3​是一个合法的概率分布。这时候，如果$\hat{y}_2=0.8$y^​2​=0.8，不管$\hat{y}_1$y^​1​和$\hat{y}_3$y^​3​的值是多少，我们都知道图像类别为猫的概率是80%。此外，我们注意到

$\underset{i}{\arg\max} o_i = \underset{i}{\arg\max} \hat{y}_i$iargmax​oi​=iargmax​y^​i​

因此softmax运算不改变预测类别输出。

• 计算效率
  • 单样本矢量计算表达式
    为了提高计算效率，我们可以将单样本分类通过矢量计算来表达。在上面的图像分类问题中，假设softmax回归的权重和偏差参数分别为

$\boldsymbol{W} = \begin{bmatrix} w_{11} & w_{12} & w_{13} \\ w_{21} & w_{22} & w_{23} \\ w_{31} & w_{32} & w_{33} \\ w_{41} & w_{42} & w_{43} \end{bmatrix},\quad \boldsymbol{b} = \begin{bmatrix} b_1 & b_2 & b_3 \end{bmatrix},$W=⎣⎢⎢⎡​w11​w21​w31​w41​​w12​w22​w32​w42​​w13​w23​w33​w43​​⎦⎥⎥⎤​,b=[b1​​b2​​b3​​],

设高和宽分别为2个像素的图像样本$i$i的特征为

$\boldsymbol{x}^{(i)} = \begin{bmatrix}x_1^{(i)} & x_2^{(i)} & x_3^{(i)} & x_4^{(i)}\end{bmatrix},$x(i)=[x1(i)​​x2(i)​​x3(i)​​x4(i)​​],

输出层的输出为

$\boldsymbol{o}^{(i)} = \begin{bmatrix}o_1^{(i)} & o_2^{(i)} & o_3^{(i)}\end{bmatrix},$o(i)=[o1(i)​​o2(i)​​o3(i)​​],

预测为狗、猫或鸡的概率分布为

$\boldsymbol{\hat{y}}^{(i)} = \begin{bmatrix}\hat{y}_1^{(i)} & \hat{y}_2^{(i)} & \hat{y}_3^{(i)}\end{bmatrix}.$y^​(i)=[y^​1(i)​​y^​2(i)​​y^​3(i)​​].

softmax回归对样本$i$i分类的矢量计算表达式为

$\begin{aligned} \boldsymbol{o}^{(i)} &= \boldsymbol{x}^{(i)} \boldsymbol{W} + \boldsymbol{b},\\ \boldsymbol{\hat{y}}^{(i)} &= \text{softmax}(\boldsymbol{o}^{(i)}). \end{aligned}$o(i)y^​(i)​=x(i)W+b,=softmax(o(i)).​

• 小批量矢量计算表达式
  为了进一步提升计算效率，我们通常对小批量数据做矢量计算。广义上讲，给定一个小批量样本，其批量大小为$n$n，输入个数（特征数）为$d$d，输出个数（类别数）为$q$q。设批量特征为$\boldsymbol{X} \in \mathbb{R}^{n \times d}$X∈Rn×d。假设softmax回归的权重和偏差参数分别为$\boldsymbol{W} \in \mathbb{R}^{d \times q}$W∈Rd×q和$\boldsymbol{b} \in \mathbb{R}^{1 \times q}$b∈R1×q。softmax回归的矢量计算表达式为

$\begin{aligned} \boldsymbol{O} &= \boldsymbol{X} \boldsymbol{W} + \boldsymbol{b},\\ \boldsymbol{\hat{Y}} &= \text{softmax}(\boldsymbol{O}), \end{aligned}$OY^​=XW+b,=softmax(O),​

其中的加法运算使用了广播机制，$\boldsymbol{O}, \boldsymbol{\hat{Y}} \in \mathbb{R}^{n \times q}$O,Y^∈Rn×q且这两个矩阵的第$i$i行分别为样本$i$i的输出$\boldsymbol{o}^{(i)}$o(i)和概率分布$\boldsymbol{\hat{y}}^{(i)}$y^​(i)。

2.2 交叉熵损失函数

对于样本$i$i，我们构造向量$\boldsymbol{y}^{(i)}\in \mathbb{R}^{q}$y(i)∈Rq ，使其第$y^{(i)}$y(i)（样本$i$i类别的离散数值）个元素为1，其余为0。这样我们的训练目标可以设为使预测概率分布$\boldsymbol{\hat y}^{(i)}$y^​(i)尽可能接近真实的标签概率分布$\boldsymbol{y}^{(i)}$y(i)。

• 平方损失估计

$\begin{aligned}Loss = |\boldsymbol{\hat y}^{(i)}-\boldsymbol{y}^{(i)}|^2/2\end{aligned}$Loss=∣y^​(i)−y(i)∣2/2​

然而，想要预测分类结果正确，我们其实并不需要预测概率完全等于标签概率。例如，在图像分类的例子里，如果$y^{(i)}=3$y(i)=3，那么我们只需要$\hat{y}^{(i)}_3$y^​3(i)​比其他两个预测值$\hat{y}^{(i)}_1$y^​1(i)​和$\hat{y}^{(i)}_2$y^​2(i)​大就行了。即使$\hat{y}^{(i)}_3$y^​3(i)​值为0.6，不管其他两个预测值为多少，类别预测均正确。而平方损失则过于严格，例如$\hat y^{(i)}_1=\hat y^{(i)}_2=0.2$y^​1(i)​=y^​2(i)​=0.2比$\hat y^{(i)}_1=0, \hat y^{(i)}_2=0.4$y^​1(i)​=0,y^​2(i)​=0.4的损失要小很多，虽然两者都有同样正确的分类预测结果。

改善上述问题的一个方法是使用更适合衡量两个概率分布差异的测量函数。其中，交叉熵（cross entropy）是一个常用的衡量方法：

$H\left(\boldsymbol y^{(i)}, \boldsymbol {\hat y}^{(i)}\right ) = -\sum_{j=1}^q y_j^{(i)} \log \hat y_j^{(i)},$H(y(i),y^​(i))=−j=1∑q​yj(i)​logy^​j(i)​,

其中带下标的$y_j^{(i)}$yj(i)​是向量$\boldsymbol y^{(i)}$y(i)中非0即1的元素，需要注意将它与样本$i$i类别的离散数值，即不带下标的$y^{(i)}$y(i)区分。在上式中，我们知道向量$\boldsymbol y^{(i)}$y(i)中只有第$y^{(i)}$y(i)个元素$y^{(i)}{y^{(i)}}$y(i)y(i)为1，其余全为0，于是$H(\boldsymbol y^{(i)}, \boldsymbol {\hat y}^{(i)}) = -\log \hat y_{y^{(i)}}^{(i)}$H(y(i),y^​(i))=−logy^​y(i)(i)​。也就是说，交叉熵只关心对正确类别的预测概率，因为只要其值足够大，就可以确保分类结果正确。当然，遇到一个样本有多个标签时，例如图像里含有不止一个物体时，我们并不能做这一步简化。但即便对于这种情况，交叉熵同样只关心对图像中出现的物体类别的预测概率。

假设训练数据集的样本数为$n$n，交叉熵损失函数定义为
$\ell(\boldsymbol{\Theta}) = \frac{1}{n} \sum_{i=1}^n H\left(\boldsymbol y^{(i)}, \boldsymbol {\hat y}^{(i)}\right ),$ℓ(Θ)=n1​i=1∑n​H(y(i),y^​(i)),

其中$\boldsymbol{\Theta}$Θ代表模型参数。同样地，如果每个样本只有一个标签，那么交叉熵损失可以简写成$\ell(\boldsymbol{\Theta}) = -(1/n) \sum_{i=1}^n \log \hat y_{y^{(i)}}^{(i)}$ℓ(Θ)=−(1/n)∑i=1n​logy^​y(i)(i)​。从另一个角度来看，我们知道最小化$\ell(\boldsymbol{\Theta})$ℓ(Θ)等价于最大化$\exp(-n\ell(\boldsymbol{\Theta}))=\prod_{i=1}^n \hat y_{y^{(i)}}^{(i)}$exp(−nℓ(Θ))=∏i=1n​y^​y(i)(i)​，即最小化交叉熵损失函数等价于最大化训练数据集所有标签类别的联合预测概率。

2.3代码

2.3.1 softmax分类从零开始版

导入包

读取数据

模型参数初始化

定义softmax模型

定义各类计算函数

训练

2.3.2 softmax分类pytorch版

# 引入包
import torch
from torch import nn
from torch.nn import init
import numpy as np
import sys
# sys.path.append("..") 
# import d2lzh_pytorch as d2l


# 加载数据
def load_data_fashion_mnist(batch_size, resize=None, root='~/Datasets/FashionMNIST'):
    """Download the fashion mnist dataset and then load into memory."""
    trans = []
    if resize:
        trans.append(torchvision.transforms.Resize(size=resize))
    trans.append(torchvision.transforms.ToTensor())
    
    transform = torchvision.transforms.Compose(trans)
    mnist_train = torchvision.datasets.FashionMNIST(root=root, train=True, download=True, transform=transform)
    mnist_test = torchvision.datasets.FashionMNIST(root=root, train=False, download=True, transform=transform)
    if sys.platform.startswith('win'):
        num_workers = 0  # 0表示不用额外的进程来加速读取数据
    else:
        num_workers = 4
    train_iter = torch.utils.data.DataLoader(mnist_train, batch_size=batch_size, shuffle=True, num_workers=num_workers)
    test_iter = torch.utils.data.DataLoader(mnist_test, batch_size=batch_size, shuffle=False, num_workers=num_workers)

    return train_iter, test_iter


batch_size = 256
train_iter, test_iter = load_data_fashion_mnist(batch_size)

# 定义网络
num_inputs = 784
num_outputs = 10

class LinearNet(nn.Module):
    def __init__(self, num_inputs, num_outputs):
        super(LinearNet, self).__init__()
        self.linear = nn.Linear(num_inputs, num_outputs)
    def forward(self, x): # x shape: (batch, 1, 28, 28)
        y = self.linear(x.view(x.shape[0], -1))
        return y
    
net = LinearNet(num_inputs, num_outputs)
print(net)

# 初始化模型参数
init.normal_(net.linear.weight,mean=0,std=0.01)
init.constant_(net.linear.bias,val=0)

# 定义损失函数优化函数
loss = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(net.parameters(), lr=0.1)

# 训练

num_epochs, lr = 5, 0.1
# 本函数已保存在d2lzh_pytorch包中方便以后使用。该函数将被逐步改进：它的完整实现将在“图像增广”一节中描述
def evaluate_accuracy(data_iter, net):
    acc_sum, n = 0.0, 0
    for X, y in data_iter:
        acc_sum += (net(X).argmax(dim=1) == y).float().sum().item()
        n += y.shape[0]
    return acc_sum / n
# 本函数已保存在d2lzh包中方便以后使用
def train_ch(net, train_iter, test_iter, loss, num_epochs, batch_size,
              params=None, lr=None, optimizer=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:
            y_hat = net(X)
            l = loss(y_hat, y).sum()
            
            # 梯度清零
            if optimizer is not None:
                optimizer.zero_grad()
            elif params is not None and params[0].grad is not None:
                for param in params:
                    param.grad.data.zero_()
            
            l.backward()
            if optimizer is None:
                sgd(params, lr, batch_size)
            else:
                optimizer.step()  # “softmax回归的简洁实现”一节将用到
            
            
            train_l_sum += l.item()
            train_acc_sum += (y_hat.argmax(dim=1) == y).sum().item()
            n += y.shape[0]
        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))

# train_ch3(net, train_iter, test_iter, cross_entropy, num_epochs, batch_size, [W, b], lr)

num_epochs = 5
train_ch(net, train_iter, test_iter, loss, num_epochs, batch_size, None, None, optimizer)

3.多层感知机

3.1 多层感知机的基本知识

深度学习主要关注多层模型。在这里，我们将以多层感知机（multilayer perceptron，MLP）为例，介绍多层神经网络的概念。

隐藏层

下图展示了一个多层感知机的神经网络图，它含有一个隐藏层，该层中有5个隐藏单元。

表达公式

具体来说，给定一个小批量样本$\boldsymbol{X} \in \mathbb{R}^{n \times d}$X∈Rn×d，其批量大小为$n$n，输入个数为$d$d。假设多层感知机只有一个隐藏层，其中隐藏单元个数为$h$h。记隐藏层的输出（也称为隐藏层变量或隐藏变量）为$\boldsymbol{H}$H，有$\boldsymbol{H} \in \mathbb{R}^{n \times h}$H∈Rn×h。因为隐藏层和输出层均是全连接层，可以设隐藏层的权重参数和偏差参数分别为$\boldsymbol{W}_h \in \mathbb{R}^{d \times h}$Wh​∈Rd×h和 $\boldsymbol{b}_h \in \mathbb{R}^{1 \times h}$bh​∈R1×h，输出层的权重和偏差参数分别为$\boldsymbol{W}_o \in \mathbb{R}^{h \times q}$Wo​∈Rh×q和$\boldsymbol{b}_o \in \mathbb{R}^{1 \times q}$bo​∈R1×q。

我们先来看一种含单隐藏层的多层感知机的设计。其输出$\boldsymbol{O} \in \mathbb{R}^{n \times q}$O∈Rn×q的计算为

$\begin{aligned} \boldsymbol{H} &= \boldsymbol{X} \boldsymbol{W}_h + \boldsymbol{b}_h,\\ \boldsymbol{O} &= \boldsymbol{H} \boldsymbol{W}_o + \boldsymbol{b}_o, \end{aligned}$HO​=XWh​+bh​,=HWo​+bo​,​

也就是将隐藏层的输出直接作为输出层的输入。如果将以上两个式子联立起来，可以得到

$\boldsymbol{O} = (\boldsymbol{X} \boldsymbol{W}_h + \boldsymbol{b}_h)\boldsymbol{W}_o + \boldsymbol{b}_o = \boldsymbol{X} \boldsymbol{W}_h\boldsymbol{W}_o + \boldsymbol{b}_h \boldsymbol{W}_o + \boldsymbol{b}_o.$O=(XWh​+bh​)Wo​+bo​=XWh​Wo​+bh​Wo​+bo​.

从联立后的式子可以看出，虽然神经网络引入了隐藏层，却依然等价于一个单层神经网络：其中输出层权重参数为$\boldsymbol{W}_h\boldsymbol{W}_o$Wh​Wo​，偏差参数为$\boldsymbol{b}_h \boldsymbol{W}_o + \boldsymbol{b}_o$bh​Wo​+bo​。不难发现，即便再添加更多的隐藏层，以上设计依然只能与仅含输出层的单层神经网络等价。

**函数

上述问题的根源在于全连接层只是对数据做仿射变换（affine transformation），而多个仿射变换的叠加仍然是一个仿射变换。解决问题的一个方法是引入非线性变换，例如对隐藏变量使用按元素运算的非线性函数进行变换，然后再作为下一个全连接层的输入。这个非线性函数被称为**函数（activation function）。

下面我们介绍几个常用的**函数：

ReLU函数

ReLU（rectified linear unit）函数提供了一个很简单的非线性变换。给定元素$x$x，该函数定义为

$\text{ReLU}(x) = \max(x, 0).$ReLU(x)=max(x,0).

可以看出，ReLU函数只保留正数元素，并将负数元素清零。为了直观地观察这一非线性变换，我们先定义一个绘图函数xyplot。

Sigmoid函数

sigmoid函数可以将元素的值变换到0和1之间：

$\text{sigmoid}(x) = \frac{1}{1 + \exp(-x)}.$sigmoid(x)=1+exp(−x)1​.

tanh函数

tanh（双曲正切）函数可以将元素的值变换到-1和1之间：

$\text{tanh}(x) = \frac{1 - \exp(-2x)}{1 + \exp(-2x)}.$tanh(x)=1+exp(−2x)1−exp(−2x)​.

我们接着绘制tanh函数。当输入接近0时，tanh函数接近线性变换。虽然该函数的形状和sigmoid函数的形状很像，但tanh函数在坐标系的原点上对称。

3.2 pytorch代码实现的例子

# 导入包
import torch
from torch import nn
from torch.nn import init
import numpy as np
import torchvision
# sys.path.append("C:\\Users\\shenzhou\\深度学习2020110\\")
# import d2lzh_pytorch 
print(torch.__version__)


# 加载数据
def load_data_fashion_mnist(batch_size, resize=None, root='~/Datasets/FashionMNIST'):
    """Download the fashion mnist dataset and then load into memory."""
    trans = []
    if resize:
        trans.append(torchvision.transforms.Resize(size=resize))
    trans.append(torchvision.transforms.ToTensor())
    
    transform = torchvision.transforms.Compose(trans)
    mnist_train = torchvision.datasets.FashionMNIST(root=root, train=True, download=True, transform=transform)
    mnist_test = torchvision.datasets.FashionMNIST(root=root, train=False, download=True, transform=transform)
    if sys.platform.startswith('win'):
        num_workers = 0  # 0表示不用额外的进程来加速读取数据
    else:
        num_workers = 4
    train_iter = torch.utils.data.DataLoader(mnist_train, batch_size=batch_size, shuffle=True, num_workers=num_workers)
    test_iter = torch.utils.data.DataLoader(mnist_test, batch_size=batch_size, shuffle=False, num_workers=num_workers)

    return train_iter, test_iter
    
batch_size=256
train_iter,test_iter=load_data_fashion_mnist(batch_size)


# 初始化模型参数
num_inputs, num_outputs, num_hiddens = 784, 10, 256

W1 = torch.tensor(np.random.normal(0, 0.01, (num_inputs, num_hiddens)), dtype=torch.float)
b1 = torch.zeros(num_hiddens, dtype=torch.float)
W2 = torch.tensor(np.random.normal(0, 0.01, (num_hiddens, num_outputs)), dtype=torch.float)
b2 = torch.zeros(num_outputs, dtype=torch.float)



# 定义**函数
def relu(X):
    return torch.max(input=X, other=torch.tensor(0.0))

# 定义网络
def net(X):
    X = X.view((-1, num_inputs))
    H = relu(torch.matmul(X, W1) + b1)
    return torch.matmul(H, W2) + b2
# 损失
loss = torch.nn.CrossEntropyLoss()
# 训练
def sgd(params, lr, batch_size):  # 本函数已保存在d2lzh_pytorch包中方便以后使用
    for param in params:
        param.data -= lr * param.grad / batch_size # 注意这里更改param时用的param.data
def evaluate_accuracy(data_iter, net):
    acc_sum, n = 0.0, 0
    for X, y in data_iter:
        acc_sum += (net(X).argmax(dim=1) == y).float().sum().item()
        n += y.shape[0]
    return acc_sum / n
def train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size,
              params=None, lr=None, optimizer=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:
            y_hat = net(X)
            l = loss(y_hat, y).sum()
            
            # 梯度清零
            if optimizer is not None:
                optimizer.zero_grad()
            elif params is not None and params[0].grad is not None:
                for param in params:
                    param.grad.data.zero_()
            
            l.backward()
            if optimizer is None:
                sgd(params, lr, batch_size)
            else:
                optimizer.step()  # “softmax回归的简洁实现”一节将用到
            
            
            train_l_sum += l.item()
            train_acc_sum += (y_hat.argmax(dim=1) == y).sum().item()
            n += y.shape[0]
        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))

num_epochs, lr = 5, 0.01
train_ch3(net, train_iter, test_iter, loss, num_epochs, batch_size, params, lr)

参考：https://github.com/ShusenTang/Dive-into-DL-PyTorch/blob/master/docs/chapter03_DL-basics/3.1_linear-regression.md