动手学深度学习：线性回归和softmax回归

内容摘自伯禹人工智能AI公益课程

线性回归的基本要素

1、模型

线性回归假设输出与各个输入之间是线性关系，例如：

$$\mathrm{p}\mathrm{r}\mathrm{i}\mathrm{c}\mathrm{e}=w_{\mathrm{a}\mathrm{r}\mathrm{e}\mathrm{a}}\cdot \mathrm{a}\mathrm{r}\mathrm{e}\mathrm{a}+w_{\mathrm{a}\mathrm{g}\mathrm{e}}\cdot \mathrm{a}\mathrm{g}\mathrm{e}+b$$

2、数据集

训练数据集（training data set）或训练集（training set）：收集的真实数据，在这个数据上面寻找模型参数来使模型的预测价格与真实价格的误差最小。

一栋房屋被称为一个样本（sample），其真实售出价格叫作标签（label），用来预测标签的两个因素叫作特征（feature）。特征用来表征样本的特点。

3、 损失函数

模型训练中，通常采用平方误差函数衡量价格预测值与真实值之间的误差。数值越小表示误差越小。
它在评估索引为 $i$ 的样本误差的表达式为

$$l^{(i)}(\mathbf{w},b)=\frac{1}{2}{\left({\hat{y}}^{(i)}-y^{(i)}\right)}^2,$$

$$L(\mathbf{w},b)=\frac{1}{n}\sum _{i=1}^n{l}^{(i)}(\mathbf{w},b)=\frac{1}{n}\sum _{i=1}^n\frac{1}{2}{\left({\mathbf{w}}^{\top }{\mathbf{x}}^{(i)}+b-y^{(i)}\right)}^2.$$

4、优化函数 - 随机梯度下降

最小化误差模型的房还是可以用解析解（analytical solution）和
数值解（numerical solution）来表示。通常的深度学习模型没有解析解，只能通过迭代的方式尽可能降低损失。

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

$$(\mathbf{w},b)\leftarrow (\mathbf{w},b)-\frac{\eta }{|\mathcal{B}|}\sum _{i\in \mathcal{B}}{\partial }_{(\mathbf{w},b)}{l}^{(i)}(\mathbf{w},b)$$

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

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

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

pytorch的一些使用:
1、torch.ones(n):创建n维1张量
2、torch.zeros(n)：创建n维0张量
3、torch.randn(num_examples, num_inputs,dtype=torch.float32)
labels.numpy():将张量转换为array
4、dataset = Data.TensorDataset(features, labels) ：合并数据集的特征和标签
eg:

data_iter = Data.DataLoader(
    dataset=dataset,            # torch TensorDataset format
    batch_size=batch_size,      # 最小批处理大小
    shuffle=True,               # 是否乱序
    num_workers=2,              # 采用多线程读取数据
)

5、torch.nn.Linear(in_features,out_features,bias=True)
6、w.requires_grad_(requires_grad=True)张量的自动求导
7、view()：resize功能
8、l.backward() ：计算批样本损失
9、sgd([w, b], lr, batch_size)：调用随机梯度下降处理批
10、w.grad.data.zero_()：梯度的清零
11、torch.manual_seed(1)：固定随机数
12、np.random.normal(0, 1, (num_examples, num_inputs))：生成正态分布，均值为0，标准差为1，输出矩阵的shape为： (num_examples, num_inputs)
13、建立网络层次的三种方法
1):方法一：

net = nn.Sequential(
    nn.Linear(num_inputs, 1)
    # 增加层
    )

2):方法二：

net = nn.Sequential()
net.add_module('linear', nn.Linear(num_inputs, 1))
#net.add_module...

3):方法三：

from collections import OrderedDict
net = nn.Sequential(OrderedDict([
          ('linear', nn.Linear(num_inputs, 1))
          # ......
        ]))

14、初始化：
1）均匀分布

torch.nn.init.uniform_(tensor, a=0, b=1)

服从~U(a,b)U(a, b)U(a,b)
2）正态分布

torch.nn.init.normal_(tensor, mean=0, std=1)

服从~N(mean,std)N(mean, std)N(mean,std)
3） 初始化为常数

torch.nn.init.constant_(tensor, val)

15、损失函数的设计：

torch.nn.MSELoss(size_average=None, reduce=None, reduction='mean')

16、SGD优化函数：

torch.optim.SGD(params, lr=, momentum=0, dampening=0, weight_decay=0, nesterov=False)

17、重置梯度：optimizer.zero_grad()
18、optimizer.step()通常用在每个mini-batch之中，更新作用。

Softmax回归部分

softmax的基本概念

• 权重矢量
  $$\begin{array}{rl}{o}_1& =x_1{w}_{11}+x_2{w}_{21}+x_3{w}_{31}+x_4{w}_{41}+b_1\end{array}$$

$$\begin{array}{rl}{o}_2& =x_1{w}_{12}+x_2{w}_{22}+x_3{w}_{32}+x_4{w}_{42}+b_2\end{array}$$

$$\begin{array}{rl}{o}_3& =x_1{w}_{13}+x_2{w}_{23}+x_3{w}_{33}+x_4{w}_{43}+b_3\end{array}$$

• 神经网络图
  softmax回归同线性回归，也是一个单层神经网络。由于每个输出$o_1,o_2,o_3$的计算都要依赖于所有的输入$x_1,x_2,x_3,x_4$，softmax回归的输出层也是一个全连接层。

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

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

• 输出问题
  直接使用输出层的输出有两个问题：
  1. 一方面，由于输出层的输出值的范围不确定，我们难以直观上判断这些值的意义。
  2. 另一方面，由于真实标签是离散值，这些离散值与不确定范围的输出值之间的误差难以衡量。

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

$${\hat{y}}_1,{\hat{y}}_2,{\hat{y}}_3=\text{softmax}(o_1,o_2,o_3)$$

其中

$$\hat{y}1=\frac{\exp (o_1)}{{\sum }_{i=1}^3\exp (o_i)},\hat{y}2=\frac{\exp (o_2)}{{\sum }_{i=1}^3\exp (o_i)},\hat{y}3=\frac{\exp (o_3)}{{\sum }_{i=1}^3\exp (o_i)}.$$

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

$$\underset{i}{\mathrm{argmax}}{o}_i=\underset{i}{\mathrm{argmax}}{\hat{y}}_i$$

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

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

$$\mathbf{W}=\left[\begin{array}{ccc}{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{array}\right],\mathbf{b}=\left[\begin{array}{ccc}{b}_1& b_2& b_3\end{array}\right],$$

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

$${\mathbf{x}}^{(i)}=\left[\begin{array}{cccc}{x}_1^{(i)}& x_2^{(i)}& x_3^{(i)}& x_4^{(i)}\end{array}\right],$$

输出层的输出为

$${\mathbf{o}}^{(i)}=\left[\begin{array}{ccc}{o}_1^{(i)}& o_2^{(i)}& o_3^{(i)}\end{array}\right],$$

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

$${\hat{\mathbf{y}}}^{(i)}=\left[\begin{array}{ccc}{\hat{y}}_1^{(i)}& {\hat{y}}_2^{(i)}& {\hat{y}}_3^{(i)}\end{array}\right].$$

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

$$\begin{array}{rl}{\mathbf{o}}^{(i)}& ={\mathbf{x}}^{(i)}\mathbf{W}+\mathbf{b},\\ {\hat{\mathbf{y}}}^{(i)}& =\text{softmax}({\mathbf{o}}^{(i)}).\end{array}$$

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

$$\begin{array}{rl}\mathbf{O}& =\mathbf{X}\mathbf{W}+\mathbf{b},\\ \hat{\mathbf{Y}}& =\text{softmax}(\mathbf{O}),\end{array}$$

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

pytorch的使用
1、torchvision包：服务于PyTorch深度学习框架的，主要用来构建计算机视觉模型。torchvision主要由以下几部分构成：
1）torchvision.datasets: 一些加载数据的函数及常用的数据集接口；
2）torchvision.models: 包含常用的模型结构（含预训练模型），例如AlexNet、VGG、ResNet等；
3）torchvision.transforms: 常用的图片变换，例如裁剪、旋转等；
4）torchvision.utils: 其他的一些有用的方法。

用法：
class torchvision.datasets.FashionMNIST(root, train=True, transform=None, target_transform=None, download=False)

1. root（string）– 数据集的根目录，其中存放processed/training.pt和processed/test.pt文件。
2. train（bool, 可选）– 如果设置为True，从training.pt创建数据集，否则从test.pt创建。
3. download（bool, 可选）– 如果设置为True，从互联网下载数据并放到root文件夹下。如果root目录下已经存在数据，不会再次下载。
4. transform（可被调用 , 可选）– 一种函数或变换，输入PIL图片，返回变换之后的数据。如：transforms.RandomCrop。
   target_transform（可被调用 , 可选）– 一种函数或变换，输入目标，进行变换。

2、对多维Tensor按维度操作

X = torch.tensor([[1, 2, 3], [4, 5, 6]])
print(X.sum(dim=0, keepdim=True))  # dim为0，按照相同的列求和，并在结果中保留列特征
print(X.sum(dim=1, keepdim=True))  # dim为1，按照相同的行求和，并在结果中保留行特征
print(X.sum(dim=0, keepdim=False)) # dim为0，按照相同的列求和，不在结果中保留列特征
print(X.sum(dim=1, keepdim=False)) # dim为1，按照相同的行求和，不在结果中保留行特征

3、
torch.mul(a, b)是矩阵a和b对应位相乘，a和b的维度必须相等，比如a的维度是(1, 2)，b的维度是(1, 2)，返回的仍是(1, 2)的矩阵
torch.mm(a, b)是矩阵a和b矩阵相乘，比如a的维度是(1, 2)，b的维度是(2, 3)，返回的就是(1, 3)的矩阵

4、交叉熵损失函数

 class torch.nn.CrossEntropyLoss(weight=None, size_average=None, ignore_index=-100, reduce=None, reduction='mean')

5、网络模型的定义

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 的形状: (batch, 1, 28, 28)
        y = self.linear(x.view(x.shape[0], -1))
        return y
    
# net = LinearNet(num_inputs, num_outputs)

class FlattenLayer(nn.Module):
    def __init__(self):
        super(FlattenLayer, self).__init__()
    def forward(self, x): # x 的形状: (batch, *, *, ...)
        return x.view(x.shape[0], -1)

from collections import OrderedDict
net = nn.Sequential(
        # FlattenLayer(),
        # LinearNet(num_inputs, num_outputs) 
        OrderedDict([
           ('flatten', FlattenLayer()),
           ('linear', nn.Linear(num_inputs, num_outputs))]) # 或者写成我们自己定义的 LinearNet(num_inputs, num_outputs) 也可以
        )