深度学习之线性回归

线性回归的基本要素

模型

基本线性模型：
$$\text{Y}=\text{X}\cdot W+\text{b}$$
具体地，已房价为例，这里我们假设价格只取决于房屋状况的两个因素，即面积$area$（平方米）和房龄$age$（年）。接下来我们希望探索价格与这两个因素的具体关系。线性回归假设输出与各个输入之间是线性关系:
$$\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$$

数据集

数据集分为训练数据集和测试数据集，数据集中的一个实例被称为一个样本。在房价预测的案例中，其真实售出价格叫作标签（label），用来预测标签的两个因素叫作特征（feature）。

损失函数

在模型训练中，我们需要衡量价格预测值与真实值之间的误差。通常我们会选取一个非负数作为误差，且数值越小表示误差越小。一个常用的选择是平方函数。 它在评估索引为 $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.$$

优化函数

当模型和损失函数形式较为简单时，上面的误差最小化问题的解可以直接用公式表达出来。这类解叫作解析解（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)我们在数据上迭代多次，通过在负梯度方向移动参数来更新每个参数。

线性回归模型从零开始实现

生成数据集

# 倒入必要的包
import torch
import matplotlib.pyplot as plt
import numpy as np

# 设置输入特征数
num_inputs = 2
# 设置实例数
num_examples = 1000

# 设置真实的权重和偏置（为了生成对应的标签）
true_w = [2, -3.4]
true_b = 4.2

# 生成数据
features = torch.randn(num_examples, num_inputs, dtype=torch.float32)
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.float32)

使用图像来展示生成的数据

房价与面积之间的正相关关系：

plt.scatter(features[:, 0].numpy(), labels.numpy(), 1)

房价与年龄之间的负相关关系：

plt.scatter(features[:, 1].numpy(), labels.numpy(), 1)

读取数据集

def data_iter(batch_size, features, labels):
	"""
	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 = torch.LongTensor(indices[i: min(i + batch_size, num_examples)])
        yield features.index_select(0, j), labels.index_select(0, j)

定义模型

定义用来训练参数的训练模型：

$$\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$$

def linreg(X, w, b):
    return torch.mm(X, w) + b

初始化模型参数

w = torch.tensor(np.random.normal(0, 0.01, (num_inputs, 1)), dtype=torch.float32)
b = torch.zeros(1, dtype=torch.float32)

w.requires_grad_(requires_grad=True)
b.requires_grad_(requires_grad=True)

定义损失函数

回归模型一般使用均方差函数作为损失函数

def squared_loss(y_hat, y):
    return (y_hat - y.view(y_hat.size())) ** 2 / 2

定义优化函数

这里优化函数使用小批量随机梯度下降：

def sgd(params, lr, batch_size):
    for param in params:
        param.data -= lr * param.grad / batch_size 

模型训练

准备好数据集、定义好模型损失函数和优化函数后就可以开始模型训练了

# 定义超参数
lr = 0.03
num_epochs = 5

net = linreg
loss = squared_loss

# 训练
for epoch in range(num_epochs):  # training repeats num_epochs times
    for X, y in data_iter(batch_size, features, labels):
        l = loss(net(X, w, b), y).sum()
        l.backward()
        sgd([w, b], lr, batch_size)
        w.grad.data.data.zero_()
        b.grad.data.zero_()
    train_l = loss(net(features, w, b), labels)
    print('epoch %d, loss %f' % (epoch + 1, train_l.mean().item()))

线性回归模型的pytorch实现

生成数据集

这里生成数据集与从零开始的实现相同。

读取数据集

import torch.utils.data as Data

batch_size = 10

# 将特征和标签整合到一起
dataset = Data.TensorDataset(features, labels)

# 将数据集放到DataLoader中，DataLoader是一个生成器
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__()  # call father function to init
        self.linear = nn.Linear(n_feature, 1)
        
    def forward(self, x):
        y = self.linear(x)
        return y
              
net = LinearNet(num_inputs)
print(net)

初始化模型参数

from torch.nn import init

init.normal_(net[0].weight, mean=0.0, std=0.01)
init.constant_(net[0].bias, val=0.0)

查看模型初始化值

for param in net.parameters():
    print(param)

定义损失函数

仍然采用均方差损失函数

loss = nn.MSELoss()

定义优化函数

import torch.optim as optim

optimizer = optim.SGD(net.parameters(), lr=0.03)
print(optimizer)

模型训练

num_epochs = 3
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()))

结果比较

dense = net[0]
print(true_w, dense.weight.data)
print(true_b, dense.bias.data)

两种实现方式的比较

• 从零开始实现可以更好的理解模型结构和神经网络的底层原理，比较考验码代码的功力
• 使用pytorch有好多模块都是现成的，只要把这些模块合理的堆叠起来就行了，所以实现起来比较方便快捷，但是对神经网络底层的实现了解不够明晰。