同学你好！本文章于2021年末编写，获得广泛的好评！

故在2022年末对本系列进行填充与更新，欢迎大家订阅最新的专栏，获取基于Pytorch1.10版本的理论代码(2023版)实现，

Pytorch深度学习·理论篇(2023版)目录地址为：

CSDN独家 | 全网首发 | Pytorch深度学习·理论篇(2023版)目录本专栏将通过系统的深度学习实例，从可解释性的角度对深度学习的原理进行讲解与分析，通过将深度学习知识与Pytorch的高效结合，帮助各位新入门的读者理解深度学习各个模板之间的关系，这些均是在Pytorch上实现的，可以有效的结合当前各位研究生的研究方向，设计人工智能的各个领域，是经过一年时间打磨的精品专栏！https://v9999.blog.csdn.net/article/details/127587345欢迎大家订阅(2023版)理论篇

以下为2021版原文~~~~

 

一、线性代数

回归是指一类为一个或多个自变量与因变量之间关系建模的方法。在自然科学和社会科学领域，回归经常用来表示输入和输出之间的关系。 在机器学习领域中的大多数任务通常都与预测（prediction）有关。

当我们想预测一个数值时，就会涉及到回归问题。常见的例子包括：预测价格（房屋、股票等）、预测住院时间（针对住院病人）、预测需求（零售销量）等。

但不是所有的预测都是回归问题。在后面的章节中，我们将介绍分类问题。分类问题的目标是预测数据属于一组类别中的哪一个。

1.1 线性回归的基本元素

线性回归基于几个简单的假设：首先，假设自变量x和因变量y之间的关系是线性的，即y可以表示为x中元素的加权和，这里通常允许包含观测值的一些噪声；其次，我们假设任何噪声都比较正常，如噪声遵循正态分布。

为了解释线性回归，我们举一个实际的例子：我们希望根据房屋的面积（平方英尺）和房龄（年）来估算房屋价格（美元）。

为了开发一个能预测房价的模型，我们需要收集一个真实的数据集。这个数据集包括了房屋的销售价格、面积和房龄。

在机器学习的术语中，该数据集称为训练数据集（training data set）或训练集（training set），每行数据（在这个例子中是与一次房屋交易相对应的数据）称为样本（sample），也可以称为数据点（data point）或数据样本（data instance）。

我们要试图预测的目标（在这个例子中是房屋价格）称为标签（label）或目标（target）。

预测所依据的自变量（面积和房龄）称为特征（feature）或协变量（covariate）。

通常，我们使用n来表示数据集中的样本数。

1.2 线性模型

线性假设是指目标（房屋价格）可以表示为特征（面积和房龄）的加权和，如下面的式子：

Warea和Wage称为权重（weight），b称为偏置（bias）、偏移量（offset）、截距（intercept）。

权重决定了每个特征对我们预测值的影响。

偏置是指当所有特征都取值为0时，预测值应该为多少，如果没有偏置项，我们模型的表达能力将受到限制。

严格来说，上式是输入特征的一个仿射变换（affine transformation）。仿射变换的特点是通过加权和对特征进行线性变换，并通过偏置项来进行平移。

给定一个数据集，我们的目标是寻找模型的权重w和偏置b，使得根据模型做出的预测大体符合数据里的真实价格。输出的预测值由输入特征通过线性模型的仿射变换决定，仿射变换由所选权重和偏置确定。

在我们开始寻找最好的模型参数w和b之前，我们还需要两个东西：
（1）一种模型质量的度量方式；
（2）一种能够更新模型以提高模型预测质量的方法。

1.3损失函数

损失函数能够量化目标的实际值与预测值之间的差距。通常我们会选择非负数作为损失，且数值越小表示损失越小，完美预测时的损失为0。回归问题中最常用的损失函数是平方误差函数。

为了进一步说明，来看下面的例子。我们为一维情况下的回归问题绘制图像，如图所示。

 

 在平方误差函数中，犹豫估计值和观测值之间的差值将使的整个模型的误差变大，因此通过损失均值可以降低误差的显示范围，如下：

在训练模型时，我们希望寻找一组参数(w,b)，这组参数能最小化在所有训练样本上的总损失。

1.3解析解

        线性回归刚好是一个很简单的优化问题。与我们将在本书中所讲到的其他大部分模型不同，线性回归的解可以用一个公式简单地表达出来，这类解叫作解析解（analytical solution）。

        线性回归这样的简单问题存在解析解，但并不是所有的问题都存在解析解。解析解可以进行很好的数学分析，但解析解的限制很严格，导致它无法应用在深度学习里。

1.4 小批量随机梯度下降

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

1.4.1小批量随机梯度下降

梯度下降最简单的用法是计算损失函数（数据集中所有样本的损失均值）关于模型参数的导数（在这里也可以称为梯度）。但实际中的执行可能会非常慢：因为在每一次更新参数之前，我们必须遍历整个数据集。

因此，我们通常会在每次需要计算更新的时候随机抽取一小批样本，这种变体叫做小批量随机梯度下降。

在每次迭代中，我们首先随机抽样一个小批量B，它是由固定数量的训练样本组成的。然后，我们计算小批量的平均损失关于模型参数的导数（也可以称为梯度）。最后，我们将梯度乘以一个预先确定的正数η，并从当前参数的值中减掉。

我们用下面的数学公式来表示这一更新过程（∂表示偏导数）：

总结一下，算法的步骤如下：

（1）初始化模型参数的值，如随机初始化；

（2）从数据集中随机抽取小批量样本且在负梯度的方向上更新参数，并不断迭代这一步骤。

对于平方损失和仿射变换，我们可以明确地写成如下形式:

公式 (3.1.10)中的w和x都是向量。在这里，更优雅的向量表示法比系数表示法（w1,w2,…,wd）更具可读性。 |B|表示每个小批量中的样本数，这也称为批量大小（batch size）。η表示学习率（learning rate）。

批量大小和学习率的值通常是手动预先指定，而不是通过模型训练得到的。

超参数指：可以调整但不在训练过程中更新的参数， 超参数通常是根据在独立的验证数据集上评估得到的训练迭代结果来调整的

调参：选择超参数的过程。

在训练了预先确定的若干迭代次数后（或者直到满足某些其他停止条件后），我们记录下模型参数的估计值，表示为w^,b^。但是，即使我们的函数确实是线性的且无噪声，这些估计值也不会使损失函数真正地达到最小值。因为算法会使得损失向最小值缓慢收敛，但却不能在有限的步数内非常精确地达到最小值。

线性回归恰好是一个在整个域中只有一个最小值的学习问题。但是对于像深度神经网络这样复杂的模型来说，损失平面上通常包含多个最小值。幸运的是，出于某种原因，深度学习实践者很少会去花费大力气寻找这样一组参数，使得在训练集上的损失达到最小。

事实上，更难做到的是找到一组参数，这组参数能够在我们从未见过的数据上实现较低的损失，这一挑战被称为泛化。

1.4.1用学习到的模型进行预测

现在我们可以通过给定的房屋面积x1和房龄x2来估计一个未包含在训练数据中的新房屋价格。给定特征估计目标的过程通常称为预测（prediction）或推断（inference）。

1.5 正态分布与平方损失

1.5.1 正态分布（normal distribution）

正态分布，也称为高斯分布和线性回归之间的关系很密切。 

下面我们定义一个Python函数来计算正态分布。

def normal(x, mu, sigma):p = 1 / math.sqrt(2 * math.pi * sigma**2)return p * np.exp(-0.5 / sigma**2 * (x - mu)**2)

我们现在可视化正态分布。

# 再次使用numpy进行可视化
x = np.arange(-7, 7, 0.01)# 均值和标准差对
params = [(0, 1), (0, 2), (3, 1)]
d2l.plot(x, [normal(x, mu, sigma) for mu, sigma in params], xlabel='x',ylabel='p(x)', figsize=(4.5, 2.5),legend=[f'mean {mu}, std {sigma}' for mu, sigma in params])

由上图可知，在高斯分布上改变均值会产生沿x轴的偏移，增加方差将会分散分布、降低其峰值。

1.5.2 均方误差损失函数（简称均方损失）

其可以用于线性回归的一个原因是：我们假设了观测中包含噪声，其中噪声服从正态分布。

噪声正态分布如下式:

1.5.3 最大似然估计量

根据最大似然估计法选择的估计量称为最大似然估计量。

虽然使许多指数函数的乘积最大化看起来很困难，但是我们可以在不改变目标的前提下，通过最大化似然对数来简化，优化通常是说最小化而不是最大化。

 因此，在高斯噪声的假设下，最小化均方误差等价于对线性模型的最大似然估计。

 1.6  从线性回归到深度网络

1.6.1 神经网络图

我们将线性回归模型描述为一个神经网络，该图只显示连接模式，即只显示每个输入如何连接到输出，隐去了权重和偏置的值。

 由于模型重点在发生计算的地方，所以通常我们在计算层数时不考虑输入层。也就是说， 图3.1.2中神经网络的层数为1。

对于线性回归，每个输入都与每个输出（在本例中只有一个输出）相连，我们将这种变换（ 图3.1.2中的输出层）称为全连接层（fully-connected layer），或称为稠密层（dense layer）。

1.6.2 神经网络与生物学

图3.1.3，这是一张由树突（dendrites，输入终端）、细胞核（nucleu，CPU）组成的生物神经元图片。轴突（axon，输出线）和轴突端子（axon terminal，输出端子）通过突触（synapse）与其他神经元连接。

 二、基础优化方法

 

 

 

 三、从零开始实现线性回归

 在这一节中，我们将只使用张量和自动求导。

PS：d2l包可以直接在conda的prompt里面输入命令 pip install -U d2l 来安装

%matplotlib inline
import random
import torch
from d2l import torch as d2l

3.1 生成数据集

在该部分生成一个包含1000个样本的数据集，每个样本包含从标准正态分布中采样的2个特征。

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) + by += torch.normal(0, 0.01, y.shape)return X, y.reshape((-1, 1))true_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = synthetic_data(true_w, true_b, 1000)

注意，features中的每一行都包含一个二维数据样本，labels中的每一行都包含一维标签值（一个标量），下面将其输出。

print('features:', features[0],'\nlabel:', labels[0])

features: tensor([-1.5273,  0.5069])
label: tensor([-0.5713])

通过生成第二个特征features[:, 1]和labels的散点图，可以直观地观察到两者之间的线性关系。

d2l.set_figsize()
d2l.plt.scatter(features[:, (1)].detach().numpy(), labels.detach().numpy(), 1);

 3.2 读取数据集

我们定义一个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]

通常，我们使用合理大小的小批量来利用GPU硬件的优势，因为GPU在并行处理方面表现出色。每个样本都可以并行地进行模型计算，且每个样本损失函数的梯度也可以被并行地计算，GPU可以在处理几百个样本时，所花费的时间不比处理一个样本时多太多。

让我们直观感受一下。读取第一个小批量数据样本并打印。每个批量的特征维度说明了批量大小和输入特征数， 同样的，批量的标签形状与batch_size相等。

batch_size = 10for X, y in data_iter(batch_size, features, labels):print(X, '\n', y)break

tensor([[-0.5309,  0.2644],[ 0.5849, -0.4633],[ 0.0618, -1.1239],[ 0.2240,  0.0085],[ 0.7633,  0.9449],[ 0.8836,  0.8245],[-2.5749, -0.5567],[-0.0975,  0.8569],[ 0.8215, -0.3621],[ 0.7872,  0.2790]])tensor([[2.2405],[6.9425],[8.1252],[4.6162],[2.5107],[3.1595],[0.9252],[1.0848],[7.0856],[4.8352]])

上面实现的迭代对于教学来说很好，但它的执行效率很低，可能会在实际问题上陷入麻烦。 例如，它要求我们将所有数据加载到内存中，并执行大量的随机内存访问。

在深度学习框架中实现的内置迭代器效率要高得多，它可以处理存储在文件中的数据和通过数据流提供的数据。

 3.3 初始化模型参数

在下面代码中，通过从均值为0、标准差为0.01的正态分布中采样随机数来初始化权重，并将偏置初始化为0。

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

在初始化参数之后，我们的任务是更新这些参数，直到这些参数足够拟合我们的数据。

每次更新都需要计算损失函数关于模型参数的梯度，我们根据梯度的变化，可以向减小损失的方向更新每个参数。

 3.4 定义模型

接下来，我们必须定义模型，将模型的输入和参数同模型的输出关联起来。 回想一下，要计算线性模型的输出，我们只需计算输入特征 X 和模型权重 w 的矩阵向量乘法后加上偏置 b 。

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

 3.5 定义损失函数

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

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

 3.6 定义优化函数

在每一步中，使用从数据集中随机抽取的一个小批量，然后根据参数计算损失的梯度。接下来，朝着减少损失的方向更新我们的参数。

我们将在这里介绍小批量随机梯度下降的工作示例，下面的函数实现小批量随机梯度下降更新。该函数接受模型参数集合、学习速率和批量大小作为输入。每一步更新的大小由学习速率lr决定。 因为我们计算的损失是一个批量样本的总和，所以我们用批量大小（batch_size）来归一化步长，这样步长大小就不会取决于我们对批量大小的选择。

def sgd(params, lr, batch_size):  #@save"""小批量随机梯度下降。"""with torch.no_grad():for param in params:param -= lr * param.grad / batch_sizeparam.grad.zero_()

 3.7 训练

现在我们已经准备好了模型训练所有需要的要素，可以实现主要的训练过程部分了。

在每次迭代中，我们读取一小批量训练样本，并通过我们的模型来获得一组预测。 计算完损失后，我们开始反向传播，存储每个参数的梯度。

最后，我们调用优化算法sgd来更新模型参数。

概括一下，我们将执行以下循环：

在每个迭代周期中，我们使用data_iter函数遍历整个数据集，并将训练数据集的所有样本都使用一次（假设样本数能够被批量大小整除）。这里的迭代周期个数num_epochs和学习率lr都是超参数，分别设为3和0.03。

设置超参数很棘手，需要通过反复试验进行调整。

lr = 0.03
num_epochs = 3
net = linreg
loss = squared_lossfor 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}')

epoch 1, loss 0.043538
epoch 2, loss 0.000165
epoch 3, loss 0.000050

因为我们使用的是自己合成的数据集，所以我们知道真正的参数是什么。 因此，我们可以通过比较真实参数和通过训练学到的参数来评估训练的成功程度。事实上，真实参数和通过训练学到的参数确实非常接近。

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

w的估计误差: tensor([0.0010, 0.0004], grad_fn=<SubBackward0>)
b的估计误差: tensor([2.0504e-05], grad_fn=<RsubBackward1>)

注意，我们不应该想当然地认为我们能够完美地恢复参数。

在机器学习中，我们通常不太关心恢复真正的参数，而更关心那些能高度准确预测的参数。

幸运的是，即使是在复杂的优化问题上，随机梯度下降通常也能找到非常好的解。其中一个原因是，在深度网络中存在许多参数组合能够实现高度精确的预测。

四、线性回归的简洁实现

通过这些框架可以自动化实现基于梯度的学习算法中重复性的工作。

在 上一节节中，我们只依赖了：（1）通过张量来进行数据存储和线性代数；（2）通过自动微分来计算梯度。实际上，由于数据迭代器、损失函数、优化器和神经网络层很常用，现代深度学习库也为我们实现了这些组件。

我们将介绍如何通过使用深度学习框架来简洁地实现上节中的线性回归模型。

4.1 生成数据集

from mxnet import autograd, gluon, np, npx
from d2l import mxnet as d2lnpx.set_np()true_w = np.array([2, -3.4])
true_b = 4.2
features, labels = d2l.synthetic_data(true_w, true_b, 1000)

4.2读取数据集

我们可以调用框架中现有的API来读取数据。我们将features和labels作为API的参数传递，并在实例化数据迭代器对象时指定batch_size。

此外，布尔值is_train表示是否希望数据迭代器对象在每个迭代周期内打乱数据。

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)batch_size = 10
data_iter = load_array((features, labels), batch_size)

使用data_iter的方式与我们在 3.2节中使用data_iter函数的方式相同。为了验证是否正常工作，让我们读取并打印第一个小批量样本。这里我们使用iter构造Python迭代器，并使用next从迭代器中获取第一项。

next(iter(data_iter))

[tensor([[-0.6054, -0.8844],[-0.7336,  1.4959],[ 0.0251, -0.5782],[-0.3874, -2.7577],[-0.2987, -1.6454],[-1.6794,  0.9353],[-1.1240,  0.0860],[ 0.7230, -0.3869],[ 0.2812, -1.3614],[ 1.4122,  0.7235]]),tensor([[ 5.9993],[-2.3407],[ 6.2172],[12.8106],[ 9.2043],[-2.3530],[ 1.6639],[ 6.9765],[ 9.3874],[ 4.5664]])]

4.3 定义模型

当我们在 3.2节中实现线性回归时，我们明确定义了模型参数变量，并编写了计算的代码，这样通过基本的线性代数运算得到输出。

我们首先定义一个模型变量net，它是一个Sequential类的实例。Sequential类为串联在一起的多个层定义了一个容器。当给定输入数据，Sequential实例将数据传入到第一层，然后将第一层的输出作为第二层的输入，依此类推。

在下面的例子中，我们的模型只包含一个层，因此实际上不需要Sequential。但是由于以后几乎所有的模型都是多层的，在这里使用Sequential会让你熟悉标准的流水线。

回顾图3.1.2中的单层网络架构，这一单层被称为全连接层（fully-connected layer），因为它的每一个输入都通过矩阵-向量乘法连接到它的每个输出。

# `nn` 是神经网络的缩写
from torch import nnnet = nn.Sequential(nn.Linear(2, 1))

4.5 初始化模型参数

 深度学习框架通常有预定义的方法来初始化参数。 我们指定每个权重参数应该从均值为0、标准差为0.01的正态分布中随机采样，偏置参数将初始化为零。

正如我们在构造nn.Linear时指定输入和输出尺寸一样。现在我们直接访问参数以设定初始值。

我们通过net[0]选择网络中的第一个图层，然后使用weight.data和bias.data方法访问参数，然后使用替换方法normal_和fill_来重写参数值。

net[0].weight.data.normal_(0, 0.01)
net[0].bias.data.fill_(0)

tensor([0.])

4.6 定义损失函数

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

loss = nn.MSELoss()

4.7 定义优化算法

小批量随机梯度下降算法是一种优化神经网络的标准工具，PyTorch在optim模块中实现了该算法的许多变种。

当我们实例化SGD实例时，我们要指定优化的参数（可通过net.parameters()从我们的模型中获得）以及优化算法所需的超参数字典。

小批量随机梯度下降只需要设置lr值，这里设置为0.03。

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

4.8 训练

通过深度学习框架的高级API来实现我们的模型只需要相对较少的代码。 我们不必单独分配参数、不必定义我们的损失函数，也不必手动实现小批量随机梯度下降。

回顾一下：在每个迭代周期里，我们将完整遍历一次数据集（train_data），不停地从中获取一个小批量的输入和相应的标签。

对于每一个小批量，我们会进行以下步骤:①通过调用net(X)生成预测并计算损失(正向传播)。

②通过进行反向传播来计算梯度。③通过调用优化器来更新模型参数。

为了更好的衡量训练效果，我们计算每个迭代周期后的损失，并打印它来监控训练过程。

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}')

epoch 1, loss 0.000254
epoch 2, loss 0.000098
epoch 3, loss 0.000098

下面我们比较生成数据集的真实参数和通过有限数据训练获得的模型参数。 要访问参数，我们首先从net访问所需的层，然后读取该层的权重和偏置。 正如在从零开始实现中一样，我们估计得到的参数与生成数据的真实参数非常接近。

w = net[0].weight.data
print('w的估计误差：', true_w - w.reshape(true_w.shape))
b = net[0].bias.data
print('b的估计误差：', true_b - b)

w的估计误差： tensor([0.0007, 0.0007])

b的估计误差： tensor([-0.0007])

五、小结

1、我们可以使用PyTorch的高级API更简洁地实现模型。

2、在PyTorch中，data模块提供了数据处理工具，nn模块定义了大量的神经网络层和常见损失函数。

3、我们可以通过_结尾的方法将参数替换，从而初始化参数。

QA：

1.推荐使用colab

2.损失为什么要平均？相当于平均了学习率

3.batchsize小点好

4.学习率和批量大小不会影响最终的结果

5.随机梯度的批量大小是根据多个样点来取值

6.datach()的作用：不参与求梯度

7.不做学习率衰减，问题不大

8.