【学习day2】softmax 回归的简洁实现

主要来源：
李沐老师的pytorch 动手学习深度学习（鞠躬感谢）
记录每日所学，欢迎讨论

与之前学习【day1】相比，这次发现通过深度学习框架的高级API能够使实现(softmax)线性(回归变得更加容易)。同样地，通过深度学习框架的高级API也能更方便地实现分类模型。让我们继续使用Fashion-MNIST数据集，并保持批量大小为256

1.初始化模型参数

读入数据到迭代器中：

import torch
from torch import nn
from d2l import torch as d2l
batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

# PyTorch不会隐式地调整输入的形状。因此，
# 我们在线性层前定义了展平层（flatten），来调整网络输入的形状
net = nn.Sequential(nn.Flatten(), nn.Linear(784, 10))

def init_weights(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, std=0.01)

net.apply(init_weights);

• nn.Flatten() flatten是会把任意维度的Tensor变为一个2D的tensor，把第0维度保留，剩下的维度全部展成一个向量，对应前一个手动实现的reshape
• Sequential: 是一个有序的容器，神经网络模块将按照在传入构造器的顺序依次被添加到计算图中执行，同时以神经网络模块为元素的有序字典也可以作为传入参数。
• nn.init.normal_(m.weight,std=0.01) 把weight init 为均值为0（默认），方差为0.01的随机值
• net.apply(init_weights) 每一层apply一下init_weight的函数

比如下面这个代码，通过Squential将网络层和激活函数结合起来，输出激活后的网络节点。：

# hyper parameters
in_dim=1
n_hidden_1=1
n_hidden_2=1
out_dim=1
class Net(nn.Module):
   def __init__(self, in_dim, n_hidden_1, n_hidden_2, out_dim):
       super().__init__()
     	self.layer = nn.Sequential(
           nn.Linear(in_dim, n_hidden_1), 
           nn.ReLU(True)，
           nn.Linear(n_hidden_1, n_hidden_2)，
           nn.ReLU(True)，
           # 最后一层不需要添加激活函数
           nn.Linear(n_hidden_2, out_dim)
            )
 	def forward(self, x):
    	x = self.layer(x)
   	return x

以下是补充的内容：
enumerate 的使用方式：
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

 seq = ['one','two','three']
 for i,element in enumerate(seq):
      print i,element

最终的结果为：
0 one
1 two
2 three

__init __call 和 forward的使用方法：

class A():
   def __init__(self, init_age):
      super().__init__()
       print('我年龄是:',init_age)
       self.age = init_age
   def __call__(self, added_age):
       res = self.forward(added_age)
       return res
   def forward(self, input_):
       print('forward 函数被调用了')        
       return input_ + self.age
print('对象初始化。。。。')
a = A(10)
input_param = a(2)
print("我现在的年龄是：", input_param)

对象初始化。。。。
我年龄是: 10
forward 函数被调用了
我现在的年龄是： 12

如果是直接调用类A，进行初始化init，形成的是实例a。
使用实例a时，先调用call函数，一般call函数中会包含forward函数
再结合具体的网络，forward是表示一个前向传播，构建网络层的先后运算步骤。
__init__主要用来做参数初始化用，我们要初始化卷积的一些参数，就可以放到里面。

2.重新审视Softmax的实现

在前面的例子中，我们计算了模型的输出，然后将此输出送入交叉熵损失。从数学上讲，这是一件完全合理的事情。然而，从计算角度来看，指数可能会造成数值稳定性问题。

回想一下，softmax函数${\hat{y}}_j=\frac{\exp (o_j)}{{\sum }_k\exp (o_k)}$，其中${\hat{y}}_j$是预测的概率分布。$o_j$是未归一化的预测$\mathbf{o}$的第$j$个元素。如果$o_k$中的一些数值非常大，那么$\exp (o_k)$可能大于数据类型容许的最大数字（即上溢（overflow））。这将使分母或分子变为inf（无穷大），我们最后遇到的是0、inf或nan（不是数字）的${\hat{y}}_j$。在这些情况下，我们不能得到一个明确定义的交叉熵的返回值。

解决这个问题的一个技巧是，在继续softmax计算之前，先从所有$o_k$中减去$\max (o_k)$。你可以证明每个$o_k$按常数进行的移动不会改变softmax的返回值。在减法和归一化步骤之后，可能有些$o_j$具有较大的负值。由于精度受限，$\exp (o_j)$将有接近零的值，即下溢（underflow）。这些值可能会四舍五入为零，使${\hat{y}}_j$为零，并且使得$\log ({\hat{y}}_j)$的值为-inf。反向传播几步后，我们可能会发现自己面对一屏幕可怕的nan结果。

尽管我们要计算指数函数，但我们最终在计算交叉熵损失时会取它们的对数。
通过将softmax和交叉熵结合在一起，可以避免反向传播过程中可能会困扰我们的数值稳定性问题。如下面的等式所示，我们避免计算$\exp (o_j)$，而可以直接使用$o_j$。因为$\log (\exp (\cdot ))$被抵消了。

$$\begin{array}{rl}\log ({\hat{y}}_j)& =\log \left(\frac{\exp (o_j)}{{\sum }_k\exp (o_k)}\right)\\ & =\log (\exp (o_j))-\log \left(\sum _k\exp (o_k)\right)\\ & =o_j-\log \left(\sum _k\exp (o_k)\right).\end{array}$$

我们也希望保留传统的softmax函数，以备我们需要评估通过模型输出的概率。
但是，我们没有将softmax概率传递到损失函数中，而是[在交叉熵损失函数中传递未归一化的预测，并同时计算softmax及其对数]，这是一件聪明的事情"LogSumExp技巧"。

loss = nn.CrossEntropyLoss()

3. 优化算法

trainer = torch.optim.SGD(net.parameters(), lr=0.1)

在SGD中传入net所有的参数，学习率为0.1

SGD：Stochastic Gradient Descent，随机梯度下降，是通过不断沿着反梯度方向更新参数求解，可以随机采样b个样本近似损失，每次随机选择一个mini-batch去计算梯度，在minibatch-loss上的梯度显然是original-loss上的梯度的无偏估计，因此利用minibatch-loss上的梯度可以近似original-loss上的梯度，并且每走一步只需要遍历一个minibatch（一～几百）的数据。

4. 训练

接下来我们调用之前定义的训练函数来训练模型。

num_epochs = 10
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)

最终训练结果：