《动手深度学习》3.1线性回归&3.2pytorch实现

线性回归的基本元素

• 线性模型
• 损失函数
• 解析解_一般只有凸优化问题存在解析解
• 基础优化方法-梯度下降
  梯度下降原理：不断地沿着损失函数递减的方向(函数在负梯度方向下降最快)上来更新参数。
  学习率：
• 小批量随机梯度下降
  批量大小：
• 线性回归应用—预测

pytorch从零实现(不使用现成框架)

%matplotlib inline ##这是魔法函数的定义，表示可以在Ipython编译器里直接使用，功能是可以内嵌绘图，并且可以省略掉plt.show()这一步。
import random
import torch
import matplotlib # 注意这个也要import一次
import matplotlib.pyplot as plt

生成数据集

目的：对原函数y=[2,-3.4]*X+4.2进行拟合，但是没有数据集啊。所以，以下代码用一个满足均值为0方差为0.01的正态分布的随机误差项生成了一批训练数据！

def synthetic_data(w, b, num_examples):  #@save
    """生成y=Xw+b+噪声"""
    X = torch.normal(0, 1, (num_examples, len(w)))
    y = torch.matmul(X, w) + b
    y += torch.normal(0, 0.01, y.shape)
    return X, y.reshape((-1, 1))
    #这里-1是指未设定行数，程序随机分配，所以这里-1表示任一正整数；即reshape(-1,1)表示（任意行，1列）

true_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = synthetic_data(true_w, true_b, 1000)

• 注意: X是1000x2；y.reshape(-1,1)中-1表示不指定行，意思就是reshape成(任意行，1列)的形状
• features中的每一行都包含一个二维数据样本， labels中的每一行都包含一维标签值（一个标量）。
• 可视化一下这2个特征features[:, 0],features[:,1]和labels的散点图， 可以直观观察到两者之间的线性关系。显然一个是正比，一个是反比。

plt.figure(1)
plt.scatter(features[:,0].detach().numpy(), labels.detach().numpy());
plt.figure(2)
plt.scatter(features[:,1].detach().numpy(), labels.detach().numpy());

读取数据集（小批量！minibatch）

• 定义一个函数， 该函数能打乱数据集中的样本并以小批量方式获取数据。
• 定义data_iter函数： 该函数接收批量大小、特征矩阵和标签向量作为输入，生成大小为batch_size的小批量。 每个小批量包含一组特征和标签。

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

调用函数，一共可以得到num_examples/batch_size组批量，每一组包含batch_size个样本！
输出来获得的前5组batch看一下下~

batch_size = 10
i = 0
for X, y in data_iter(batch_size, features, labels):
    print(X, '\n', y)
    i += 1
    if(i>5): break

利用GPU并行运算的优势，处理合理大小的“小批量”。 每个样本都可以并行地进行模型计算，且每个样本损失函数的梯度也可以被并行计算。 高效！！

当函数迭代时，我们会连续地获得不同的小批量，直至遍历完整个数据集。 上面实现的迭代对于教学来说很好，但它的执行效率很低，可能会在实际问题上陷入麻烦。 例如，它要求我们将所有数据加载到内存中，并执行大量的随机内存访问。 在深度学习框架中实现的内置迭代器效率要高得多， 它可以处理存储在文件中的数据和数据流提供的数据。

初始化模型参数

• 用小批量随机梯度下降优化模型参数之前， 需要先有一些参数(随机预设)。so…通过正态分布中采样随机数来初始化权重， 并将偏置b初始化为0。

w = torch.normal(0, 0.01, size=(2,1), requires_grad=True)
b = torch.zeros(1, requires_grad=True)

• 接下来！开始更新这些参数，直到这些参数足够拟合我们的数据。 并使用pytorch的自动求导来计算每次更新需要的梯度值！

定义"线性回归"模型

def linreg(X, w, b):  #@save
    """线性回归模型"""
    return torch.matmul(X, w) + b

定义损失函数-均方误差

def squared_loss(y_hat, y):  #@save
    """均方损失"""
    return (y_hat - y.reshape(y_hat.shape)) ** 2 / 2

• 也就是我们的前馈(forward)计算过程，即运行模型时会构建一个计算图！

定义优化算法-minibatch梯度下降

1. 每一步中，从数据集中随机抽取一个小批量，然后根据参数计算损失的梯度。
2. 接下来，朝着减少损失的方向更新参数。
3. 以下函数输入参数为：模型参数集合、学习率和批量大小。学习速率lr决定每一步更新的大小。
4. 因为我们计算的损失是一个批量样本的总和(而不是均值)，为避免batch_size影响到loss值的大小，我们给它求个均值(除以batch_size)来规范化一下。
   

def sgd(params, lr, batch_size):  #@save
    """小批量随机梯度下降"""
    with torch.no_grad():
        for param in params:
            param -= lr * param.grad / batch_size
            param.grad.zero_()#更新完将梯度清零！

训练

1. 在for的每次循环中，我们每次读取一个batch的训练样本，通过模型来获得一组预测。
2. 计算损失(前馈过程forward，构建计算图)
3. 然后，开始反向传播，存储每个参数的梯度。 （因为loss的shape是(batch_size,1)，不是一个标量，所以考虑求sum将l中的所有元素加到一起，再以此计算关于[w,b]的梯度）
4. 最后，我们调用优化算法sgd来更新模型参数。
   

lr = 0.03
num_epochs = 3
net = linreg
loss = squared_loss

for epoch in range(num_epochs):
    for X, y in data_iter(batch_size, features, labels):
        l = loss(net(X, w, b), y)  # X和y的小批量损失
        # 因为l形状是(batch_size,1)，而不是一个标量。l中的所有元素被加到一起，
        # 并以此计算关于[w,b]的梯度
        l.sum().backward()
        sgd([w, b], lr, batch_size)  # 使用参数的梯度更新参数
    with torch.no_grad(): #以下计算过程不自动计算导数
        train_l = loss(net(features, w, b), labels)
        print(f'epoch {epoch + 1}, loss {float(train_l.mean()):f}')

误差验证：看一下用这些数据拟合计算的w,b和原本真实的true_w,true_b差了多少吧

print(f'w的估计误差: {true_w - w.reshape(true_w.shape)}')
print(f'b的估计误差: {true_b - b}')

——————————————————————————————

python语法基础补充

reshape(-1,1)

• reshape(-1,1)中-1表示不指定行，意思就是reshape成(任意行，1列)的形状

random.shuffle()

• 函数用法: random.shuffle()用于将一个列表中的元素打乱顺序，值得注意的是使用这个方法不会生成新的列表，只是将原列表的次序打乱。

with torch.no_grad()

首先看with

• 在pytorch写的网络中，with torch.no_grad():非常常见。
• 关于python中的with：
  with 语句适用于对资源进行访问的场合，确保不管使用过程中是否发生异常都会执行必要的清理操作，释放资源，比如文件使用后自动关闭／线程中锁的自动获取和释放等。
• with工作原理：
  （１）紧跟with后面的语句被求值后，返回对象的“–enter–()”方法被调用，这个方法的返回值将被赋值给as后面的变量；
  （２）当with后面的代码块全部被执行完之后，将调用前面返回对象的“–exit–()”方法。
  

with torch.no_grad的作用

• 在该模块下，所有计算得出的tensor的requires_grad都自动设置为False。
• 即使一个tensor（记为x）的requires_grad = True，在with
  torch.no_grad下计算时，由x计算得到的其他tensor（比如记为z）的requires_grad也为False，不会对z求导。