第一章 线性模型

一、线性模型基本概念

线性模型：$\hat{y}=x\ast \omega +b$

简化版本，将 $b$ 加入到权重矩阵 $\omega$ 中：$\hat{y}=x\ast \omega$

单个样本的损失函数：$loss=(\hat{y}-y{)}^2=(x\ast \omega -y{)}^2$

整个 $trainingset$ 的损失函数（Mean Square Error, MSE）：$cost=\frac{1}{N}{\sum }_{n=1}^N(\widehat{y_n}-y_n{)}^2$

代码实现及绘图：

import numpy as np
import matplotlib.pyplot as plt

x_data = [1.0, 2.0, 3.0]
y_data = [2.0, 4.0, 6.0]


def forward(x):  # 定义模型
    return x * w


def loss(x, y):  # 损失函数
    y_pred = forward(x)
    return (y_pred - y) * (y_pred - y)


w_list = []
mse_list = []

for w in np.arange(0.0, 4.1, 0.1):
    print('w=', w)
    l_sum = 0
    for x_val, y_val in zip(x_data, y_data):
        y_pred_val = forward(x_val)
        loss_val = loss(x_val, y_val)
        l_sum += loss_val
        print('\t', x_val, y_val, y_pred_val, loss_val)
    print('MSE=', l_sum / 3)
    w_list.append(w)
    mse_list.append(l_sum / 3)

plt.plot(w_list, mse_list)
plt.ylabel('loss')
plt.xlabel('w')
plt.show()

二、梯度下降

损失函数 MSE：$cost=\frac{1}{N}{\sum }_{n=1}^N(\widehat{y_n}-y_n{)}^2$

为了使损失函数最小，即需要找到一个 ${\omega }^{\ast }$ 使得 $cost$ 值最小：${\omega }^{\ast }=\underset{\omega }{argmincost(\omega )}$

梯度：$$\begin{array}{rl}Gradient& =\frac{\partial cost}{\partial \omega }\\ & =\frac{\partial }{\partial \omega }\frac{1}{N}\sum _{n=1}^N(x_n\cdot \omega -y_n{)}^2\\ & =\frac{1}{N}\sum _{n=1}^N\frac{\partial }{\partial \omega }(x_n\cdot \omega -y_n{)}^2\\ & =\frac{1}{N}\sum _{n=1}^{N}2\cdot (x_n\cdot \omega -y_n)\frac{\partial (x_n\cdot \omega -y_n)}{\partial \omega }\\ & =\frac{1}{N}\sum _{n=1}^{N}2\cdot x_n\cdot (x_n\cdot \omega -y_n)\end{array}$$

梯度更新：$$\begin{array}{rl}\omega & =\omega -\alpha \frac{\partial cost}{\partial \omega }\\ & =\omega -\alpha \frac{1}{N}\sum _{n=1}^{N}2\cdot x_n\cdot (x_n\cdot \omega -y_n)\end{array}$$

代码实现：

import matplotlib.pyplot as plt

x_data = [1.0, 2.0, 3.0]
y_data = [2.0, 4.0, 6.0]

w = 1.0


def forward(x):
    return x * w


def cost(xs, ys):
    cost = 0
    for x, y in zip(xs, ys):
        y_pred = forward(x)
        cost += (y_pred - y) ** 2
    return cost / len(xs)


def gradinet(xs, ys):
    grad = 0
    for x, y in zip(xs, ys):
        grad += 2 * x * (x * w - y)
    return grad / len(xs)


print('Predict (before training)', 4, forward(4))

Epoch_list = []
loss_list = []

for epoch in range(100):
    cost_val = cost(x_data, y_data)
    grad_val = gradinet(x_data, y_data)
    w -= 0.01 * grad_val
    Epoch_list.append(epoch)
    loss_list.append(cost_val)
    print('Epoch:', epoch, 'w=', w, 'loss=', cost_val)

print('Predict (after training)', 4, forward(4))

plt.plot(Epoch_list, loss_list)
plt.xlabel('Epoch')
plt.ylabel('cost')
plt.show()

随机梯度下降（Stochastic Gradient Desce，SGD），多指 mini-batch 的随机梯度下降。

三、反向传播

首先了解计算图，对于一个两层的神经网络模型：$$\begin{array}{rl}\hat{y}& =W_2(W_1\cdot X+b_1)+b_2\\ & =W_2\cdot W_1\cdot X+(W_2{b}_1+b_2)\\ & =W\cdot X+b\end{array}$$对于这个模型，可以构建计算图如下：
由上式可以知道，不管多少层的一个线性的神经网络模型，都可以化简为一个仅包含一层的神经网络模型，这样的话，那些设计多个隐藏层的神经网络模型就没有意义了。所以在每一层的结尾都需要一个非线性函数，改进后的模型如下，其中 $\sigma$ 表示一个非线性函数。

课程中这里有对链式求导法则的讲解，但是那个很简单，这里就跳过了。

有了计算图，就可以开始了解传播算法了。下面是一个例子，先进性前馈传播，再进行反向传播，虽然在 Pytorch 这样的框架里面实现了自动求解梯度的功能，但是下面的两张图是原理的解释。

下面是一个计算的实例：

下面使用 Pytorch 实现一下传播算法。

注意，在 Pytorch 中的一个基本单位是张量（Tensor），它可以用于动态创建计算图，其中包含数据（data）以及损失函数对于该张量（一般是指权重）的梯度（grad）。

import torch
import matplotlib.pyplot as plt

x_data = [1.0, 2.0, 3.0]
y_data = [2.0, 4.0, 6.0]

# 创建一个张量并且需要自动计算梯度
w = torch.Tensor([1.0])
w.requires_grad = True


# 构建计算图
def forward(x):
    return x * w  # 注意这里计算的时候x也被转换为了张量


def loss(x, y):
    y_pred = forward(x)
    return (y_pred - y) ** 2


print('predict (before training)', 4, forward(4).item())

epoch_list = []
l_list = []

for epoch in range(100):
    for x, y in zip(x_data, y_data):
        l = loss(x, y)
        l.backward()
        epoch_list.append(epoch)
        l_list.append(l.item())
        print('\tgrad:', x, y, w.grad.item())
        w.data = w.data - 0.01 * w.grad.data
        w.grad.data.zero_()  # 梯度置零，否则会累加
    print('progress:', epoch, l.item())

print('predict (after training)', 4, forward(4).item())

plt.plot(epoch_list, l_list)
plt.xlabel('epoch')
plt.ylabel('loss')
plt.show()

四、使用 Pytorch 实现线性模型

import torch

x_data = torch.Tensor([[1.0], [2.0], [3.0]])
y_data = torch.Tensor([[2.0], [4.0], [6.0]])


class LinearModel(torch.nn.Module):
    def __init__(self):
        super(LinearModel, self).__init__()  # 调用父类的构造函数
        self.linear = torch.nn.Linear(1, 1)  # 权重和偏置值的维度feature

    def forward(self, x):
        y_pred = self.linear(x)  # 对象后面接参数，调用了__call__()方法
        return y_pred


model = LinearModel()

criterion = torch.nn.MSELoss(reduction='sum')  # 损失函数
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)  # 优化方法：梯度下降

for epoch in range(1000):
    y_pred = model(x_data)  # forward，调用了__call__()方法
    loss = criterion(y_pred, y_data)
    print(epoch, loss.item())

    optimizer.zero_grad()  # 梯度置零
    loss.backward()
    optimizer.step()  # 更新梯度


print('w=', model.linear.weight.item())
print('b=', model.linear.bias.item())

x_test = torch.Tensor([[4.0]])
y_test = model(x_test)
print('y_pred=', y_test.item())