机器学习西瓜书笔记——线性回归

datawhale——task02

线性回归

二元线性回归在直角坐标系中拟合出一条直线，多元线性回归在解空间内拟合出一个超平面。线性回归解释了自变量（特征）与因变量之间的关系，可以根据自变量得到因变量的值。线性回归可以理解为单层神经网络，当线性模型有两个输入时，他就是一个感知机。

线性回归的表达式为：
$$\hat{y}=b+w_1{x}_1+w_2{x}_2+\cdot \cdot \cdot +w_n{x}_n$$
为了方便计算，写成矩阵的形式
$$\begin{gathered} y=原始数据\left[\begin{array}{c}{\hat{y}}_1\\ {\hat{y}}_2\\ ⋮\\ {\hat{y}}_n\end{array}\right]拟合出的数据\hat{y}=\left[\begin{array}{c}{\hat{y}}_1\\ {\hat{y}}_2\\ ⋮\\ {\hat{y}}_n\end{array}\right]参数矩阵（权重矩阵）\vec{w}=\left[\begin{array}{c}b\\ w_1\\ w_2\\ ⋮\\ w_n\end{array}\right]自变量矩阵\vec{X}=\left[\begin{array}{cc}1& x_1\\ 1& x_2\\ 1& x_3\\ ⋮⋮& \\ 1& x_n\end{array}\right] \\ \hat{y}=\vec{X}\vec{w} \end{gathered}$$

训练损失：

转换成L2范式的样式:
$$\ell (\mathbf{X},\mathbf{y},\mathbf{w})=\frac{1}{2n}\Vert \mathbf{y}-\mathbf{Xw}{\Vert }^2$$

参数优化：让损失\ell最小即可，即$$w^{\ast },b^{\ast }=arg\underset{w,b}{\min }\ell$$，求解方法就是loss对w矩阵求导，令导函数等于0
$$\frac{\partial \ell }{\partial w}=0$$

解法1:直接求导
$$\begin{array}{rl}\frac{\partial \ell }{\partial w}& =\frac{1}{2n}\frac{\partial (y-Xw)(y-Xw{)}^T}{\partial w}\\ & =\frac{1}{2n}\frac{\partial (y{y}^T-y{X}^T{w}^T-Xw{y}^T+Xw{X}^T{w}^T)}{\partial w}\\ & =\frac{1}{2n}\frac{\partial (y{y}^T-2Xw{y}^T+Xw{X}^T{w}^T)}{\partial w}\\ & =\frac{1}{2n}(0-2X^{T}y+2X{X}^{T}w)\\ & =\frac{1}{n}(X{X}^{T}w-X^{T}y)=0\end{array}$$
化简求解得
$$\begin{gathered} X{X}^{T}w=X^{T}y \\ w=X^{T}y(X{X}^T{)}^{-1} \end{gathered}$$

解法2:链式求导法则（正向累积）
$$\begin{gathered} a=Xwb=y-a\ell =b^2 \\ \frac{\partial \ell }{\partial w}=\frac{\partial \ell }{\partial b}\frac{\partial b}{\partial a}\frac{\partial a}{\partial w} \\ =\frac{1}{2n}2b(-1)X^T \\ =\frac{1}{n}(y-Xw)X^T=0 \\ 求解得：w=y{X}^T(X{X}^T{)}^{-1} \end{gathered}$$

优化算法

梯度下降

对于简单的线性回归参数矩阵的最优解有时是有解析解的，但是当特征的数量大于样本量时一般是没有解析解的，并且这种没有解析解的情况在实际的情景中非常常见所以这里直接讨论如何使用梯度下降算法求解参数矩阵的最优解

梯度下降的一般解释：每次沿着本轮训练的梯度的反方向走一小步，直到走到最优点附近。具体每次走多少由超参数 η 确定。η 不能太大也不能太小，太大每次回走太远导致错过最优点，导致w震荡

下面使用torch的自动求导功能求参数矩阵的梯度，然后定义一个函数专门进行梯度下降操作。代码部分结合了李沐老师动手深度学习课程中的代码

import torch
import numpy as np
import matplotlib.pyplot as plt

def generat_data(w,b,data_num):
    features=torch.randn(data_num,len(w));
    labels=torch.multiply(w,features).sum(axis=1)+b
    labels+=torch.normal(0,0.1,labels.shape)
    return features,labels

def linreg_matrix(X,w):
    return X@w

def squared_loss(y_hat,y):
    return (y_hat-y.reshape(y_hat.shape))**2/2/len(y)  

def sgd(w,lr):
    # w参数矩阵
    with torch.no_grad():
        w -= lr * w.grad
        w.grad.zero_()
        

w_true=torch.tensor([8,5.56,-3.33,5.33,1.02,4.98,4.45,3.21,-6.78,7.33]);
b_true=2.0
data_num=1000
features,labels=generat_data(w_true,b_true,data_num)

# 可视化生成的数据
fig, axs = plt.subplots(10, 1,figsize=(5, 60))
for i in range(0,len(axs)):
    axs[i].scatter(features[:,i], labels)
plt.show()




lr=0.1
epochs=60
# 初始化weight和feature
w=torch.randn(11,1,requires_grad=True)
X=torch.cat([features,torch.ones(len(features),1)],dim=1)
y=labels
# print(X.shape)
# print(X[0:5,:])
loss_history=[]
for epoch in range(0,epochs):
    y_hat=linreg_matrix(X,w)
    loss=squared_loss(y_hat,y)
    loss.sum().backward()
    sgd(w,lr)
    with torch.no_grad():
        epoch_loss=squared_loss(y,linreg_matrix(X,w))
        print(f'epoch：{epoch + 1},loss：{float(epoch_loss.mean()):f}')
        loss_history.append(epoch_loss.mean())


plt.plot(np.linspace(0,epochs+1,epochs),loss_history)
plt.xlabel('epoch')
plt.ylabel('loss')
plt.title('TrainLoss')
plt.show()

批量随机梯度下降

批量随机梯度下降引入了批量batch的概念，学过操作系统的同学都知道有单道批处理系统，这两者的batch的概念是相同的。批量随机梯度下降就是将一个很大的样本随机分成多个批次，每次只使用一个批次的样本进行训练（梯度下降），这样会大大减小处理器的压力，同时由于打乱了样本的顺序还会提高模型的泛化能力。

import torch
import numpy as np
import matplotlib.pyplot as plt

def generat_data(w,b,data_num):
    features=torch.randn(data_num,len(w));
    labels=torch.multiply(w,features).sum(axis=1)+b
    labels+=torch.normal(0,0.1,labels.shape)
    return features,labels
# 分批
def data_iter(batch_size,features,labels):
    num_examples=len(features);
    indices=list(range(num_examples))
#     打乱顺序
    random.shuffle(indices)
#     从0遍历，步长为batch_size
    for i in range(0,num_examples,batch_size):
        batch_indices=torch.tensor(indices[i:min(i+batch_size,num_examples)])
        yield features[batch_indices,:],labels[batch_indices]
# 定义线性模型
def linreg(X,w,b):
    # X是数据特征。w，b是初始化好的数据。w，b在定义tensor时要设置requires_grad=True。保存梯度信息
    return X@w+b
def squared_loss(y_hat,y):
    return (y_hat-y.reshape(y_hat.shape))**2/2


def sgd(params,lr,batch_size):
    # 参数向量
    # 小批量梯度下降
    with torch.no_grad():
        for param in params:
            param -= lr * param.grad /batch_size
            param.grad.zero_()          

w_true=torch.tensor([8,5.56,-3.33,5.33,1.02,4.98,4.45,3.21,-6.78,7.33]);
b_true=2.0
data_num=1000
features,labels=generat_data(w_true,b_true,data_num)

# 可视化生成的数据
fig, axs = plt.subplots(10, 1,figsize=(5, 60))
for i in range(0,len(axs)):
    axs[i].scatter(features[:,i], labels)
plt.show()

# 开始训练
lr = 0.06
batch_size=10
epochs=20
#  eg：初始化参数
w=torch.normal(0,0.01,size=(10,1),requires_grad=True)
b=torch.rand(size=(),requires_grad=True)
# 创建图像
epoch_losses=[]
for epoch in range(0,epochs):
    for X,y in data_iter(batch_size,features,labels):
        y_hat=linreg(X,w,b)
        loss=squared_loss(y_hat,y)
        #对损失值求导
        loss.sum().backward()
        sgd([w,b],lr,batch_size)
    with torch.no_grad():
        epoch_loss = squared_loss(linreg(features,w,b),labels)
        epoch_losses.append(epoch_loss.mean())
        # print(f'epoch：{epoch + 1},loss：{float(epoch_loss.mean()):f}')
    # 更新图像

plt.plot(np.linspace(0,epochs+1,epochs),epoch_losses)
plt.xlabel('epoch')
plt.ylabel('loss')
plt.title('TrainLoss')
plt.show()