深度学习之线性回归+基础优化

Posted 2022-07-13 彭祥.

线性回归可以看作一个最简单的神经网络模型

损失函数

在我们开始考虑如何用模型拟合（fit）数据之前，我们需要确定一个拟合程度的度量。 损失函数（loss function）能够量化目标的实际值与预测值之间的差距。 通常我们会选择非负数作为损失，且数值越小表示损失越小，完美预测时的损失为0。 回归问题中最常用的损失函数是平方误差函数。当样本的预测值为，其相应的真实标签为时， 平方误差可以定义为以下公式：

梯度下降算法

梯度下降（gradient descent）， 这种方法几乎可以优化所有深度学习模型。 它通过不断地在损失函数递减的方向上更新参数来降低误差

学习率选择

计算梯度即要对我们的损失函数进行求导，这个损失函数是我们对所有样本的平均损失，即我们求一次梯度，要将整个样本计算一遍，这是十分昂贵的，因此我们可以随机选取一部分样本来进行计算

梯度的计算复杂度与样本个数是线性相关的
关于批量大小的选择
批量太小：每次计算量太小，不适合并行使用计算资源，因为我们在使用GPU运行时，由于GPU含有许多核，因此便并行计算
批量太大：内存消耗增加，浪费计算

总结

从零开始实现线性回归

数据集生成

包括数据流水线，模型，损失函数，小批量随机梯度优化器
我们将根据带有噪声的线性模型构造一个人造数据集，我们使用线性模型参数w=[2,-3.4]T,b=4.2和噪声项$来实现、 和噪声项生成数据集及其标签

import random  #随机初始化项，随机权重
import torch
from d2l import torch as d2l
def synthetic_data(w, b, num_examples):  #@save
    """生成y=Xw+b+噪声"""
    X = torch.normal(0, 1, (num_examples, len(w)))#x为均值为0，方差为1的随机数，大小为n个样本，列数为w长度
    y = torch.matmul(X, w) + b#偏差为b
    y += torch.normal(0, 0.01, y.shape)#加入噪音，均值为0，方差为0.01，形状与y相同
    return X, y.reshape((-1, 1))#将y做成列向量返回

true_w = torch.tensor([2, -3.4])#定义真实的w和真实的b
true_b = 4.2
features, labels = synthetic_data(true_w, true_b, 1000)
#以上是训练样本的生成过程
print('features:', features[0],'\\nlabel:', labels[0])

这里是生成数据集的一个过程，即生成数据集X与对应标签y，其符合

数据集读取

训练模型时要对数据集进行遍历，每次抽取一小批量样本，并使用它们来更新我们的模型。 由于这个过程是训练机器学习算法的基础，所以有必要定义一个函数， 该函数能打乱数据集中的样本并以小批量方式获取数据。
在下面的代码中，我们定义一个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]
batch_size = 10
for X, y in data_iter(batch_size, features, labels):
    print(X, '\\n', y)
    break

初始化模型参数

在我们开始用小批量随机梯度下降优化我们的模型参数之前， 我们需要先有一些参数。 在下面的代码中，我们通过从均值为0、标准差为0.01的正态分布中采样随机数来初始化权重， 并将偏置初始化为0
w为2*1的向量，并要求梯度

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

在初始化参数之后，我们的任务是更新这些参数，直到这些参数足够拟合我们的数据。 每次更新都需要计算损失函数关于模型参数的梯度。 有了这个梯度，我们就可以向减小损失的方向更新每个参数。 因为手动计算梯度很枯燥而且容易出错，所以没有人会手动计算梯度。 我们使用 自动微分来计算梯度。

定义模型

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

定义损失函数

计算损失函数的梯度，所以我们应该先定义损失函数。 这里我们使用平方损失函数。 在实现中，我们需要将真实值y的形状转换为和预测值y_hat的形状相同

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

定义优化算法

这里的优化算法使用的是梯度下降算法
在每一步中，使用从数据集中随机抽取的一个小批量，然后根据参数计算损失的梯度。 接下来，朝着减少损失的方向更新我们的参数。 下面的函数实现小批量随机梯度下降更新。 该函数接受模型参数集合、学习速率和批量大小作为输入。每 一步更新的大小由学习速率lr决定。 因为我们计算的损失是一个批量样本的总和，所以我们用批量大小（batch_size） 来规范化步长，这样步长大小就不会取决于我们对批量大小的选择。

def sgd(params, lr, batch_size):  #@save  params参数中包含w和b
    """小批量随机梯度下降"""
    with torch.no_grad():#不要计算梯度
        for param in params:
            param -= lr * param.grad / batch_size
            param.grad.zero_()#梯度清零

训练

现在我们已经准备好了模型训练所有需要的要素，可以实现主要的训练过程部分了。 理解这段代码至关重要，因为从事深度学习后， 你会一遍又一遍地看到几乎相同的训练过程。 在每次迭代中，我们读取一小批量训练样本，并通过我们的模型来获得一组预测。 计算完损失后，我们开始反向传播，存储每个参数的梯度。 最后，我们调用优化算法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')

因为我们使用的是自己合成的数据集，所以我们知道真正的参数是什么

在这里我们可以实验不同的超参数对我们的实验的影响，如设置学习率很小

可以看到，其训练三次后损失依旧很大
当然我们可以选择不同的参数来进行实验，这里就不一一展示了，接下来我们使用pytorch中的模型来简易实现线性回归模型

线性回归的简洁实现

#生成数据集与读取

import numpy as np
import torch
from d2l import torch as d2l
from torch.utils import data
ture_w=torch.tensor([2,-3.4])
ture_b=4.2
features,labels=d2l.synthetic_data(ture_w,ture_b,1000)
def load_array(data_arrays, batch_size, is_train=True):  #@save
    """构造一个PyTorch数据迭代器"""
    dataset = data.TensorDataset(*data_arrays)
    return data.DataLoader(dataset, batch_size, shuffle=is_train)
#调用框架中现有的API来读取数据。 我们将features和labels作为API的参数传递，
#并通过数据迭代器指定batch_size。 此外，布尔值is_train表示是否希望数据迭代器对象在每个迭代周期内打乱数据
batch_size = 10
data_iter = load_array((features, labels), batch_size)
next(iter(data_iter))#使用iter构造Python迭代器，并使用next从迭代器中获取第一项

定义模型

对于标准深度学习模型，我们可以使用框架的预定义好的层。这使我们只需关注使用哪些层来构造模型，而不必关注层的实现细节。 我们首先定义一个模型变量net，它是一个Sequential类的实例。 Sequential类将多个层串联在一起。 当给定输入数据时，Sequential实例将数据传入到第一层， 然后将第一层的输出作为第二层的输入，以此类推。 在下面的例子中，我们的模型只包含一个层，因此实际上不需要Sequential。 但是由于以后几乎所有的模型都是多层的，在这里使用Sequential会让你熟悉“标准的流水线”。
在PyTorch中，全连接层在Linear类中定义。 值得注意的是，我们将两个参数传递到nn.Linear中。 第一个指定输入特征形状，即2，第二个指定输出特征形状，输出特征形状为单个标量，因此为1。

# nn是神经网络的缩写 ，这是pytorch写法
from torch import nn
net = nn.Sequential(nn.Linear(2, 1))
# keras是TensorFlow的高级API，这是tensorflow写法
net = tf.keras.Sequential()
net.add(tf.keras.layers.Dense(1))

初始化模型参数

在使用net之前，我们需要初始化模型参数。 如在线性回归模型中的权重和偏置。 深度学习框架通常有预定义的方法来初始化参数。 在这里，我们指定每个权重参数应该从均值为0、标准差为0.01的正态分布中随机采样， 偏置参数将初始化为零。

net[0].weight.data.normal_(0, 0.01)
net[0].bias.data.fill_(0)
#tensorflow写法
initializer = tf.initializers.RandomNormal(stddev=0.01)
net = tf.keras.Sequential()
net.add(tf.keras.layers.Dense(1, kernel_initializer=initializer))

定义损失函数

计算均方误差使用的是MSELoss类，也称为平方范数。 默认情况下，它返回所有样本损失的平均值。

loss = nn.MSELoss()

定义优化算法

小批量随机梯度下降算法是一种优化神经网络的标准工具， PyTorch在optim模块中实现了该算法的许多变种。 当我们实例化一个SGD实例时，我们要指定优化的参数 （可通过net.parameters()从我们的模型中获得）以及优化算法所需的超参数字典。 小批量随机梯度下降只需要设置lr值，这里设置为0.03。

trainer = torch.optim.SGD(net.parameters(), lr=0.03)

通过深度学习框架的高级API来实现我们的模型只需要相对较少的代码。 我们不必单独分配参数、不必定义我们的损失函数，也不必手动实现小批量随机梯度下降。 当我们需要更复杂的模型时，高级API的优势将大大增加。 当我们有了所有的基本组件，训练过程代码与我们从零开始实现时所做的非常相似。
回顾一下：在每个迭代周期里，我们将完整遍历一次数据集（train_data）， 不停地从中获取一个小批量的输入和相应的标签。 对于每一个小批量，我们会进行以下步骤:
通过调用net(X)生成预测并计算损失l（前向传播）。
通过进行反向传播来计算梯度。
通过调用优化器来更新模型参数。
为了更好的衡量训练效果，我们计算每个迭代周期后的损失，并打印它来监控训练过程。

num_epochs = 3
for epoch in range(num_epochs):
    for X, y in data_iter:
        l = loss(net(X) ,y)
        trainer.zero_grad()
        l.backward()
        trainer.step()
    l = loss(net(features), labels)
    print(f'epoch epoch + 1, loss l:f')
w = net[0].weight.data
print('w的估计误差：', true_w - w.reshape(true_w.shape))
b = net[0].bias.data
print('b的估计误差：', true_b - b)

完整代码

import numpy as np
import torch
from d2l import torch as d2l
from torch.utils import data
true_w=torch.tensor([2,-3.4])
true_b=4.2
features,labels=d2l.synthetic_data(true_w,true_b,1000)#生成有1000个数据
def load_array(data_arrays, batch_size, is_train=True):  #@save
    """构造一个PyTorch数据迭代器"""
    dataset = data.TensorDataset(*data_arrays)
    return data.DataLoader(dataset, batch_size, shuffle=is_train)
#调用框架中现有的API来读取数据。 我们将features和labels作为API的参数传递，
#并通过数据迭代器指定batch_size。 此外，布尔值is_train表示是否希望数据迭代器对象在每个迭代周期内打乱数据
batch_size = 10
data_iter = load_array((features, labels), batch_size)
len(features),next(iter(data_iter))#使用iter构造Python迭代器，并使用next从迭代器中获取第一项
# nn是神经网络的缩写,定义模型
from torch import nn
net = nn.Sequential(nn.Linear(2, 1))
#初始化模型参数
net[0].weight.data.normal_(0, 0.01)
net[0].bias.data.fill_(0)
#定义损失函数
loss = nn.MSELoss()
#定义优化算法
trainer = torch.optim.SGD(net.parameters(), lr=0.03)
#开始训练
num_epochs = 3
for epoch in range(num_epochs):
    for X, y in data_iter:
        l = loss(net(X) ,y)
        trainer.zero_grad()
        l.backward()
        trainer.step()
    l = loss(net(features), labels)
    print(f'epoch epoch + 1, loss l:f')
#比较生成数据集的真实参数和通过有限数据训练获得的模型参数
w = net[0].weight.data
print('w的估计误差：', true_w - w.reshape(true_w.shape))
b = net[0].bias.data
print('b的估计误差：', true_b - b)