线性回归

主要内容包括：

1. 线性回归的基本要素

模型

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

$\mathrm{price} = w_{\mathrm{area}} \cdot \mathrm{area} + w_{\mathrm{age}} \cdot \mathrm{age} + b$

数据集

我们通常收集一系列的真实数据，例如多栋房屋的真实售出价格和它们对应的面积和房龄。我们希望在这个数据上面寻找模型参数来使模型的预测价格与真实价格的误差最小。在机器学习术语里，该数据集被称为训练数据集（training data set）或训练集（training set），一栋房屋被称为一个样本（sample），其真实售出价格叫作标签（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)我们在数据上迭代多次，通过在负梯度方向移动参数来更新每个参数。

矢量计算

矢量计算比采用循环的标量相加快很多，因此应该尽可能使用矢量运算

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

1 生成数据集

使用线性模型生成数据集（dataset），采用如下线性关系来生成：
$\mathrm{price} = w_{\mathrm{area}} \cdot \mathrm{area} + w_{\mathrm{age}} \cdot \mathrm{age} + b$

num_inputs = 2
num_examples = 1500
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[:, 1].numpy(), labels.numpy(), 1) 
#tensor不可以直接用于绘图，所以我们需要将tensor数据先转换成为numpy（）数据

在这里插入图片描述

2 读取数据集

def data_iter(batch_size, features, labels):
    num_examples = len(features)
    indices = list(range(num_examples))
    random.shuffle(indices)  # random read 10 samples
    for i in range(0, num_examples, batch_size):
        j = torch.LongTensor(indices[i: min(i + batch_size, num_examples)]) # the last time may be not enough for a whole batch
        yield  features.index_select(0, j), labels.index_select(0, j)
batch_size = 10

for X, y in data_iter(batch_size, features, labels):
    print(X, '\n',X.size(),'\n',y,'\n', y.size())
    # b = X.view(-1)
    # print(b.size())
    break

在这里插入图片描述

训练

# 初始化超参数
lr = 0.02
num_epochs = 5
net = linreg
loss = squared_loss
# training
for epoch in range(num_epochs):
# X is the feature and y is the label of a batch sample
    for X, y in data_iter(batch_size, features, labels):
        l = loss(net(X, w, b), y).sum()  
        # calculate the gradient of batch sample loss 
        l.backward()  
        # using small batch random gradient descent to iter model parameters
        sgd([w, b], lr, batch_size)  
        # reset parameter gradient
        w.grad.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()))

在这里插入图片描述

3. 线性回归模型使用pytorch的简洁实现

import torch
from torch import nn
import numpy as np
torch.manual_seed(1)

print(torch.__version__)
torch.set_default_tensor_type('torch.FloatTensor')

# 读取数据
import torch.utils.data as Data

batch_size = 10
# 将特征数据和标签合并为dataset
dataset = Data.TensorDataset(features, labels)

# 将数据传入DataLoader
data_iter = Data.DataLoader(
    dataset=dataset,# torch TensorDataset format
    batch_size=batch_size,# mini batch size
    shuffle=True,# whether shuffle data or not
    num_workers=2,)# read data in multithreading)

# 定义模型
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)

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)

初始化模型参数
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)

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

# 定义损失函数
loss = nn.MSELoss()

# 定义优化函数
import torch.optim as optim

optimizer = optim.SGD(net.parameters(), lr = 0.02)

# 进行训练
num_epochs = 5
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()))

在这里插入图片描述

课后习题

在这里插入图片描述

示例图所示不难分析出来，每一个输入为（8 * 1）对应一个（1 * 1）的输出，另外需要添加一个b的偏置项。最开始我认为有7个输入向量，应该有7个b.所以选了D项。
实际上仔细分析模型，可以得到b是整个模型的一个值与输入的哪个向量无关，所以只有一个b，根据广播机制所以偏置项为即可（1 * 1）。
在这里插入图片描述
进行向量计算，必须两个向量形状一致，或者符合广播规范。 y_hat 是 [n, 1], y 是[n].
y.view(-1),表示将y向量变为一个行向量即y.size() = [n].与y_hat 不一致所以计算出错。

直接将数据带入loss函数进行计算即可：
在这里插入图片描述