线性回归
回归（regression）是能为一个或多个自变量与因变量之间关系建模的一类方法。 在自然科学和社会科学领域，回归经常用来表示输入和输出之间的关系。
在机器学习领域中的大多数任务通常都与预测（prediction）有关。 当我们想预测一个数值时，就会涉及到回归问题。 常见的例子包括：预测价格（房屋、股票等）、预测住院时间（针对住院病人等）、 预测需求（零售销量等）。 但不是所有的预测都是回归问题。 在后面的章节中，我们将介绍分类问题。分类问题的目标是预测数据属于一组类别中的哪一个。
线性回归的基本元素
首先，假设自变量x和因变量y之间是线性关系的，也就是y可以表示为x中元素的加权和。
假设一栋房子的价格可以有房子的面积和房龄决定，为了开发一套预测房屋价格的模型，我们需要先去收集大量数据，这些数据称为训练集，每行数据（没套房子的完整信息）称为样本。我们所想要预测的目标（例如房子的价格）称为标签或目标，预测所依赖的自变量称为特征或协变量。
通常我们使用n来表示训练集中样本的数量。对索引为i的样本,其输入表示为
x
(
i
)
=
[
x
1
(
i
)
,
x
2
(
i
)
]
T
x^{(i)}=[x_1^{(i)},x_2^{(i)}]^T
x(i)=[x1(i),x2(i)]T，其对应的标签为
y
(
i
)
y^{(i)}
y(i)
线性模型
线性假设是指标签（房价），可以表现为特征（面积和房龄）的加权和,如下式：
p
r
i
c
e
=
w
a
r
e
a
.
a
r
e
a
+
w
a
g
e
.
a
g
e
+
b
price = w_{area}.area + w_{age}.age + b
price=warea.area+wage.age+b
其中两个
w
a
r
e
a
,
w
a
g
e
w_{area},w_{age}
warea,wage是特征的权重，b是偏移量或截距。
给定一个数据集，我们的目标是寻找模型的权重和偏置，使得根据模型做出的预测大体符合数据里的真实价格。
而在机器学习领域，我们通常使用的是高维数据集，建模时采用线性代数表示法会比较方便。 当我们的输入包含d个特征时，我们将预测结果$\hat y
$（通常使用“尖角”符号表示的估计值）表示为：
y
^
=
w
1
x
1
+
.
.
.
+
w
d
x
d
+
b
\hat y = w_1x_1+...+w_dx_d+b
y^=w1x1+...+wdxd+b
将所有特征放到向量
x
∈
R
d
x\in \mathbb{R}^d
x∈Rd中,并将所有权重放到
w
∈
R
d
w\in \mathbb{R}^d
w∈Rd中。我们可以用点积的形式简洁的表示模型：
y
^
=
w
T
x
+
b
\hat y = w^Tx+b
y^=wTx+b
损失函数
在我们开始考虑如何用模型拟合（fit）数据之前，我们需要确定一个拟合程度的度量。 损失函数（loss function）能够量化目标的实际值与预测值之间的差距。 通常我们会选择非负数作为损失，且数值越小表示损失越小，完美预测时的损失为0。 回归问题中最常用的损失函数是平方误差函数。当样本
i
i
i的预测值为
y
^
(
i
)
\hat y^{(i)}
y^(i),其相应的真实标签为
y
^
(
i
)
\hat y^{(i)}
y^(i)时，平方误差可以定义为以下公式：
l
(
i
)
(
w
,
b
)
=
1
2
(
y
^
(
i
)
−
y
(
i
)
)
2
l^{(i)}(w,b)=\frac{1}{2}(\hat y^{(i)}-y^{(i)})^2
l(i)(w,b)=21(y^(i)−y(i))2
常数
1
2
\frac{1}{2}
21不会带来本质的差别，但这样在形式上稍微简单一些 （因为当我们对损失函数求导后常数系数为1）。 由于训练数据集并不受我们控制，所以经验误差只是关于模型参数的函数。 为了进一步说明，来看下面的例子。 我们为一维情况下的回归问题绘制图像,如下:
由于平方误差函数中的二次方项，估计值
y
^
(
i
)
\hat y^{(i)}
y^(i)和观测值
y
(
i
)
y^{(i)}
y(i)之间较大的差异将导致更大的损失。 为了度量模型在整个数据集上的质量，我们需计算在训练集
n
n
n个样本上的损失均值（也等价于求和）:
L
(
w
,
b
)
=
1
n
∑
i
=
1
n
l
(
i
)
(
w
,
b
)
=
1
n
∑
i
=
1
n
1
2
(
w
T
x
(
i
)
+
b
−
y
(
i
)
)
2
L(w,b) = \frac{1}{n}\sum_{i=1}^nl^{(i)}(w,b)=\frac{1}{n}\sum_{i=1}^n\frac{1}{2}(w^Tx^{(i)}+b-y^{(i)})^2
L(w,b)=n1i=1∑nl(i)(w,b)=n1i=1∑n21(wTx(i)+b−y(i))2
在训练模型时我们希望找到一组参数
(
w
∗
,
b
∗
)
(w^*,b^*)
(w∗,b∗)，这组参数能最小化在所有训练样本上的总损失。如下式：
w
∗
,
b
∗
=
a
r
g
m
i
n
w
,
b
L
(
w
,
b
)
w^*,b^* = \underset{w,b}{argmin} L(w,b)
w∗,b∗=w,bargminL(w,b)
解析解
线性回归刚好是一个很简单的优化问题。 与我们将在本书中所讲到的其他大部分模型不同，线性回归的解可以用一个公式简单地表达出来， 这类解叫作解析解（analytical solution）。 首先，我们将偏置
b
b
b合并到参数
w
w
w中，合并方法是在包含所有参数的矩阵中附加一列。 我们的预测问题是最小化
∣
∣
y
−
X
w
∣
∣
2
||y-Xw||^2
∣∣y−Xw∣∣2。 这在损失平面上只有一个临界点，这个临界点对应于整个区域的损失极小点。 将损失关于
w
w
w的导数设为0，得到解析解：
w
∗
=
(
X
T
X
)
−
1
X
T
y
w^*=(X^TX)^{-1}X^Ty
w∗=(XTX)−1XTy
像线性回归这样的简单问题存在解析解，但并不是所有的问题都存在解析解。 解析解可以进行很好的数学分析，但解析解对问题的限制很严格，导致它无法广泛应用在深度学习里。
随机梯度下降
即使在我们无法得到解析解的情况下，我们仍然可以有效地训练模型。 在许多任务上，那些难以优化的模型效果要更好。 因此，弄清楚如何训练这些难以优化的模型是非常重要的。
本书中我们用到一种名为梯度下降（gradient descent）的方法， 这种方法几乎可以优化所有深度学习模型。 它通过不断地在损失函数递减的方向上更新参数来降低误差。
梯度下降最简单的用法是计算损失函数（数据集中所有样本的损失均值） 关于模型参数的导数（在这里也可以称为梯度）。 但实际中的执行可能会非常慢：因为在每一次更新参数之前，我们必须遍历整个数据集。 因此，我们通常会在每次需要计算更新的时候随机抽取一小批样本， 这种变体叫做小批量随机梯度下降（minibatch stochastic gradient descent）。
在每次迭代中，我们首先随机抽取一个小批量
β
\beta
β,然后我们计算小批量损失函数关于模型参数的导数（也可以称作梯度）。最后我们将梯度乘以一个预先确定的正数
η
\eta
η（学习率），再除以小批量样本数
∣
β
∣
|\beta|
∣β∣，并从当前参数的值中减掉。
总结一下，算法的步骤如下： （1）初始化模型参数的值，如随机初始化； （2）从数据集中随机抽取小批量样本且在负梯度的方向上更新参数，并不断迭代这一步骤。 对于平方损失和仿射变换，我们可以明确地写成如下形式:
$$
w_{new}\gets w - \frac{\eta}{|\beta|}\sum_{i\in\beta}\sigma_wl^{(i)}(w,b)= w - \frac{\eta}{|\beta|}\sum_{i\in \beta}x{(i)}(wTx{(i)}+b-y{(i)})\
b_{new}\gets b - \frac{\eta}{|\beta|}\sum_{i\in\beta}\sigma_bl^{(i)}(w,b)= b - \frac{\eta}{|\beta|}\sum_{i\in \beta}(wTx{(i)}+b-y^{(i)})
$$
KaTeX parse error: Can't use function '$' in math mode at position 21: …面数学公式来表示一下更新过程（$̲\sigma$表示偏导数）:
(w,b) \gets (w,b) - \frac{\eta}{|\beta|}\sum_{i\in \beta}\sigma_{(w,b)}l^{(i)}(w,b)
$$
上式中
w
,
x
w,x
w,x都是向量。在这里，更优雅的向量表示法比系数表示法（如
w
1
,
w
2
,
.
.
.
,
w
d
w_1,w_2,...,w_d
w1,w2,...,wd）更具有可读性.
∣
β
∣
|\beta|
∣β∣表示小批量样本的数量（batch size）。
η
\eta
η表示学习率。批量大小和学习率是预先指定的，不是训练模型得到的/这些可以调整但不在训练过程中更新的参数称为超参数。调参是选择超参数的过程。
在训练了预先确定的若干迭代次数后（或者直到满足某些其他停止条件后）， 我们记录下模型参数的估计值，表示为 w ^ , b ^ \hat w,\hat b w^,b^。 但是，即使我们的函数确实是线性的且无噪声，这些估计值也不会使损失函数真正地达到最小值。 因为算法会使得损失向最小值缓慢收敛，但却不能在有限的步数内非常精确地达到最小值。
线性回归恰好是一个在整个域中只有一个最小值的学习问题。 但是对像深度神经网络这样复杂的模型来说，损失平面上通常包含多个最小值。 深度学习实践者很少会去花费大力气寻找这样一组参数，使得在训练集上的损失达到最小。 事实上，更难做到的是找到一组参数，这组参数能够在我们从未见过的数据上实现较低的损失， 这一挑战被称为泛化（generalization）。
矢量化加速
在训练我们的模型时，我们经常希望能够同时处理整个小批量的样本。 为了实现这一点，需要我们对计算进行矢量化， 从而利用线性代数库，而不是在Python中编写开销高昂的for循环。
import math
import time
import numpy as np
import torch
from d2l import torch as d2l
from matplotlib import pyplot as plt
由于在本书中我们将频繁地进行运行时间的基准测试，所以我们定义一个计时器：
class Timer:
# 记录多次运行的时间
def __init__(self):
self.times = []
self.start()
def start(self):
"""启动计时器"""
self.tik = time.time()
def stop(self):
"""停止计时器并将时间记录在列表中"""
self.times.append(time.time()-self.tik)
return self.times[-1]
def avg(self):
"""返回平均时间"""
return sum(self.times)/len(self.times)
def summ(self):
"""返回时间综总和"""
return sum(self.times)
def cumsum(self):
"""返回累计时间"""
return np.array(self.times).cumsum().tolist()
现在我们可以对工作负载进行基准测试。
首先，我们使用for循环，每次执行一位的加法。
n = 100
a = torch.ones(n)
b = torch.ones(n)
c = torch.zeros(n)
timer = Timer()
for i in range(n):
c[i] = a[i] + b[i]
timer.stop()
0.010473012924194336
timer.start()
d = a + b
timer.stop()
0.0
结果很明显，第二种方法比第一种方法快得多。 矢量化代码通常会带来数量级的加速。 另外，我们将更多的数学运算放到库中，而无须自己编写那么多的计算，从而减少了出错的可能性。
正态分布与平方损失
接下来，我们通过对噪声分布的假设来解读平方损失目标函数。
正态分布和线性回归之间的关系很密切。 正态分布（normal distribution），也称为高斯分布（Gaussian distribution）， 最早由德国数学家高斯（Gauss）应用于天文学研究。 简单的说，若随机变量 x x x具有均值 μ \mu μ和方差 σ 2 \sigma ^2 σ2（标准差 σ \sigma σ），其正态分布概率密度函数如下：
f ( x ) = 1 2 π σ e − ( x − μ ) 2 2 σ 2 f(x) = \frac{1}{\sqrt{2\pi\sigma}}e^-\frac{(x-\mu)^2}{2\sigma^2} f(x)=2πσ1e−2σ2(x−μ)2
下面定义一个函数计算正态分布。
def normal(x,mu,sigma):
p = 1/math.sqrt(2*math.pi*sigma)
return p*np.exp(-(x-mu)**2/2*sigma**2)
现在我们可视化正态分布。
# 定义取值范围和间隔
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)',legend=[f'mean {mu},std {sigma}' for mu,sigma in params],figsize=(4.5,2.5))
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-drEGfYnZ-1680579378680)(null)]
就像我们所看到的，改变均值会产生沿x轴的偏移，增加方差将会分散分布、降低其峰值。
小结
-
机器学习模型中的关键要素是训练数据、损失函数、优化算法，还有模型本身。
-
矢量化使数学表达上更简洁，同时运行的更快。
-
最小化目标函数和执行极大似然估计等价。
-
线性回归模型也是一个简单的神经网络。
练习
线性回归从零开始实现
在了解线性回归的关键思想之后，我们可以开始通过代码来动手实现线性回归了。 在这一节中，我们将从零开始实现整个方法， 包括数据流水线、模型、损失函数和小批量随机梯度下降优化器。 虽然现代的深度学习框架几乎可以自动化地进行所有这些工作，但从零开始实现可以确保我们真正知道自己在做什么。 同时，了解更细致的工作原理将方便我们自定义模型、自定义层或自定义损失函数。 在这一节中，我们将只使用张量和自动求导。 在之后的章节中，我们会充分利用深度学习框架的优势，介绍更简洁的实现方式。
import random
import torch
from d2l import torch as d2l
生成数据集
为了简单起见，我们将根据带有噪声的线性模型构造一个人造数据集。 我们的任务是使用这个有限样本的数据集来恢复这个模型的参数。 我们将使用低维数据，这样可以很容易地将其可视化。 在下面的代码中，我们生成一个包含1000个样本的数据集， 每个样本包含从标准正态分布中采样的2个特征。 我们的合成数据集是一个矩阵$X\in \mathbb{R}^{1000*2} $
我们使用线性模型参数
w
=
[
2
,
−
3.4
]
T
、
b
=
4.2
w=[2,-3.4]^T、b=4.2
w=[2,−3.4]T、b=4.2和噪声项
ϵ
\epsilon
ϵ生成数据集及其标签：
y
=
X
w
+
b
+
ϵ
y = Xw+b+\epsilon
y=Xw+b+ϵ
ϵ
\epsilon
ϵ可以视为模型预测和标签时的潜在观测误差。 在这里我们认为标准假设成立，即
ϵ
\epsilon
ϵ服从均值为0的正态分布。 为了简化问题，我们将标准差设为0.01。 下面的代码生成合成数据集。
'''
synthetic_data(合成数据)
w：权重
b：偏移量
num_examples：生成样本的大小
'''
def synthetic_data(w,b,num_examples):
# 从均值为0,标准差为1的正态分布中采样随机数,生成（1000*2）的数据集
X = torch.normal(0,1,(num_examples,len(w)))
# y=Xw+b
y = torch.matmul(X,w)+b
# y=Xw+b+噪声,噪声符合均值为0，标准差为0.01，形状=y.shape
y+= torch.normal(0,0.01,y.shape)
# 将目标转化为和特征一样的形状，x(1000*2),y(1000*1)
return X,y.reshape(-1,1)
true_w = torch.tensor([2,-3.4])
true_b = 4.2
# 得到随机生成的特征值和目标
features,lables = synthetic_data(true_w,true_b,1000)
注意，features中的每一行都包含一个二维数据样本， labels中的每一行都包含一维标签值（一个标量）
print('features:',features[0],'lables:',lables[0])
features: tensor([-1.5077, 1.3884]) lables: tensor([-3.5424])
plt.scatter(features[:,1],lables)
<matplotlib.collections.PathCollection at 0x20ec9c4c550>
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-O7xlsDtO-1680579378577)(null)]
我们绘制第二个特征features[:,1]和lables的散点图，可以观察到两者间的线性关系
读取数据集
我们通过随机小批量梯度下降法进行线性回归，因此每次要从样本中随机抽取小批量的样本。
因此我们定义一个函数data_iter函数，该函数接收数据集，和批量大小，生成大小为batch_size的小批量，每个小批量数据集含有一组特征和对应的标签。
def data_iter(features,lables,batch_size):
num_examples = len(features)
indices = list(range(num_examples))
# 将数据集的索引打乱，这样在取的时候相当于是随机读取
random.shuffle(indices)
# 从0遍历到num_examples，每次步长为batch_size
for i in range(0,num_examples,batch_size):
# min防止超出列表索引
batch_indices = torch.tensor(indices[i:min(i+batch_size,num_examples)])
# 每次取出[i:i+batch_size]个样本，也就是10个样本
yield features[batch_indices],lables[batch_indices]
batch_size = 10
for X,y in data_iter(features,lables,batch_size):
print(X,'\n',y)
break
tensor([[-0.8209, -0.3893],
[ 2.3439, 1.9330],
[ 1.1874, -0.4204],
[-0.9635, -1.9056],
[ 0.5265, -2.0734],
[-0.0847, -1.2406],
[ 1.2889, 0.4121],
[-2.3453, 1.9717],
[ 0.7579, -0.8275],
[ 0.3513, -0.0792]])
tensor([[ 3.8798],
[ 2.3276],
[ 8.0033],
[ 8.7556],
[12.2891],
[ 8.2537],
[ 5.3843],
[-7.1861],
[ 8.5407],
[ 5.1566]])
当我们运行迭代时，我们会连续地获得不同的小批量，直至遍历完整个数据集。 上面实现的迭代对教学来说很好，但它的执行效率很低，可能会在实际问题上陷入麻烦。 例如，它要求我们将所有数据加载到内存中，并执行大量的随机内存访问。 在深度学习框架中实现的内置迭代器效率要高得多， 它可以处理存储在文件中的数据和数据流提供的数据。
初始化参数模型
我们首先初始化我们猜测的权重 w ^ , b ^ \hat w,\hat b w^,b^,然后再生成模型。，我们通过从均值为0、标准差为0.01的正态分布中采样随机数来初始化权重， 并将偏置初始化为0。
# 生成猜测权重
w = torch.normal(0,0.01,size=(2,1),requires_grad=True)
b = torch.zeros(1, requires_grad=True)
定义模型
接下来，我们必须定义模型，将模型的输入和参数同模型的输出关联起来。 回想一下，要计算线性模型的输出， 我们只需计算输入特征 X X X和模型权重 w w w的矩阵-向量乘法后加上偏置 b b b。 注意，上面的 X w Xw Xw是一个向量，而 b b b是一个标量。 回想一下 2.1.3节中描述的广播机制： 当我们用一个向量加一个标量时，标量会被加到向量的每个分量上。
# 定义线性回归模型模型
def linemode(X,w,b):
return torch.matmul(X,w)+b
定义损失函数
因为需要计算损失函数的梯度，所以我们应该先定义损失函数。 这里我们使用 3.1节中描述的平方损失函数。 在实现中，我们需要将真实值y的形状转换为和预测值y_hat的形状相同。
# 定义损失函数,y_hat,预测值
def square_loss(y_hat,y):
return (y_hat-y.reshape(y_hat.shape))**2/2
定义优化算法（随机梯度下降）
( w , b ) ← ( w , b ) − η ∣ β ∣ ∑ i ∈ β σ ( w , b ) l ( i ) ( w , b ) (w,b) \gets (w,b) - \frac{\eta}{|\beta|}\sum_{i\in \beta}\sigma_{(w,b)}l^{(i)}(w,b) (w,b)←(w,b)−∣β∣ηi∈β∑σ(w,b)l(i)(w,b)
def sgd(params,lr,batch_size):
'''
params：权重向量
lr：学习率
'''
with torch.no_grad():
for params in params:
params -= lr*params.grad/batch_size
params.grad.zero_()
训练
现在我们已经准备好了模型训练所有需要的要素，可以实现主要的训练过程部分了。 理解这段代码至关重要，因为从事深度学习后， 相同的训练过程几乎一遍又一遍地出现。 在每次迭代中，我们读取一小批量训练样本，并通过我们的模型来获得一组预测。 计算完损失后，我们开始反向传播，存储每个参数的梯度。 最后，我们调用优化算法sgd来更新模型参数。
概括一下，我们将执行以下循环：
- 初始化参数
- 重复一下训练，知道完成
- 计算梯度 g ← σ ( w , n ) 1 ∣ β ∣ ∑ i ∈ β l ( x ( i ) , y ( i ) , w , b ) g \gets \sigma_{(w,n)}\frac{1}{|\beta|}\sum_{i\in\beta}l(x^{(i)},y^{(i)},w,b) g←σ(w,n)∣β∣1∑i∈βl(x(i),y(i),w,b)
- 更新参数 ( w , b ) ← ( w , b ) − η g (w,b) \gets (w,b)-\eta g (w,b)←(w,b)−ηg
在每个迭代周期（epoch）中，我们使用data_iter函数遍历整个数据集， 并将训练数据集中所有样本都使用一次（假设样本数能够被批量大小整除）。 这里的迭代周期个数num_epochs和学习率lr都是超参数，分别设为3和0.03。
lr = 0.03
num_epochs = 3
net = linemode
loss = square_loss
for epoch in range(num_epochs):
for X,y in data_iter(features,lables,batch_size):
l = loss(net(X,w,b),y) # 得到损失函数
# 因为l形状是(batch_size,1)，而不是一个标量。l中的所有元素被加到一起
# 以此计算[w,b]的梯度，先backward
l.sum().backward()
sgd([w,b],lr,batch_size) # 使用参数的梯度更新参数
with torch.no_grad():
train_l = loss(net(features,w,b),lables)
print(f'epoch {epoch+1},loss {float(train_l.mean()):f}')
print(f'w {w},b {b}')
epoch 1,loss 0.042972
w tensor([[ 1.8712],
[-3.2492]], requires_grad=True),b tensor([3.9766], requires_grad=True)
epoch 2,loss 0.000168
w tensor([[ 1.9927],
[-3.3936]], requires_grad=True),b tensor([4.1873], requires_grad=True)
epoch 3,loss 0.000051
w tensor([[ 1.9996],
[-3.3994]], requires_grad=True),b tensor([4.1990], requires_grad=True)
因为我们使用的是自己合成的数据集，所以我们知道真正的参数是什么。 因此，我们可以通过比较真实参数和通过训练学到的参数来评估训练的成功程度。 事实上，真实参数和通过训练学到的参数确实非常接近。
print(f'w的估计误差: {true_w - w.reshape(true_w.shape)}')
print(f'b的估计误差: {true_b - b}')
w的估计误差: tensor([-0.0003, -0.0002], grad_fn=<SubBackward0>)
b的估计误差: tensor([-0.0002], grad_fn=<RsubBackward1>)
注意，我们不应该想当然地认为我们能够完美地求解参数。 在机器学习中，我们通常不太关心恢复真正的参数，而更关心如何高度准确预测参数。 幸运的是，即使是在复杂的优化问题上，随机梯度下降通常也能找到非常好的解。 其中一个原因是，在深度网络中存在许多参数组合能够实现高度精确的预测。
小结
- 我们学习了深度网络是如何实现和优化的。在这一过程中只使用张量和自动微分，不需要定义层或复杂的优化器。
- 这一节只触及到了表面知识。在下面的部分中，我们将基于刚刚介绍的概念描述其他模型，并学习如何更简洁地实现其他模型。
练习
-
权重初始为0编译错误，梯度类型为NonrType，貌似不是很意外， w x wx wx直接原地消失了。算法当然无效。。。
-
应该可以吧？和导体材质，温度，体积，长度等有关？猜测的，找找数据试一下。
-
这个也可以吧。和上面一样的问题是物体和导体的体积不一定规则。
-
想到一个就是一阶导后自变量项为0了，这个再导就为0了，暂时没想到解决办法。。。
-
两个形状一样才可以按元素运算，因为不确定形状，但两个形状一致肯定没毛病，前提是大小可以确定相同
-
学习率越大下降越快
-
最后的小批量样本数量和前面的不一样
电压电流模型
随机生成均值为1，标准差为0.01的电流
I
I
I数据集。我们设定电阻为4.5
Ω
\Omega
Ω，噪音为0.5，这里的噪音可以是热量
J
J
J等。
U
=
I
.
R
+
J
U = I.R + J
U=I.R+J
# 生成数据集
def dataset(R,data_sum):
'''
w：权重（电阻）
b：噪音（热量等）
sum_data：生成样本的大小
'''
I = torch.normal(1,0.01,(data_sum,len(R)))
U = torch.matmul(I,R)
U += torch.normal(0,0.01,U.shape)
return I,U.reshape(-1,1)
ture_R = torch.tensor([4.5])
features,lables = dataset(ture_R,500)
f'I:{features[0]},U:{lables[0]}'
'I:tensor([1.0042]),U:tensor([4.5301])'
# 读取数据
def data_gets(features,lables,batch_size):
data_sum = len(features)
index = list(range(data_sum))
random.shuffle(index)
for i in range(0,data_sum,batch_size):
index_set = torch.tensor(index[i:min(i+batch_size,data_sum)])
yield features[index_set],lables[index_set]
batch_size = 10
# 测试数据读取
for X,u in data_gets(features,lables,batch_size):
print(X,'\n',u)
print(X.shape)
break
# 初始化参数模型
R = torch.normal(0,0.01,size=(1,1),requires_grad=True)
# 定义模型
def line(X,R):
return torch.matmul(X,R)
# 定义损失函数
def loss(u_hat,u):
# print(u_hat.shape)
# print(u.shape)
return (u_hat-u.reshape(u_hat.shape))**2/2
# 定义优化算法
def sdg(params,lr,batch_size):
with torch.no_grad():
for param in params:
param -= lr*param.grad/batch_size
param.grad.zero_()
# 开始训练
lr = 0.04
num_epochs = 4
for epoch in range(num_epochs):
for X,u in data_gets(features,lables,batch_size):
l = loss(line(X,R),u)
l.sum().backward()
sdg([R],lr,batch_size)
with torch.no_grad():
train = loss(line(features,R),lables)
print(f'epoch:{epoch+1},loss:{float(train.mean()):f}')
print(f'ture:{ture_R},train:{R}')
epoch:1,loss:0.169343
ture:tensor([4.5000]),train:tensor([[3.9193]], requires_grad=True)
epoch:2,loss:0.002900
ture:tensor([4.5000]),train:tensor([[4.4252]], requires_grad=True)
epoch:3,loss:0.000098
ture:tensor([4.5000]),train:tensor([[4.4908]], requires_grad=True)
epoch:4,loss:0.000050
ture:tensor([4.5000]),train:tensor([[4.4996]], requires_grad=True)
简易手动实现求梯度
import numpy as np
import copy
def numerical_gradient(f,x,y):
h = 0.0001
grad = np.zeros_like(x)#生成和x形状相同的数组
for idx in range(x.shape[0]):
#print(x.shape)
tmp_val = copy.copy(x[idx])
# f(x+h)的计算
x[idx] = tmp_val + h
fxh1 = f(x[idx],y[idx])
# print(fxh1)
x[idx] = tmp_val - h
fxh2 = f(x[idx],y[idx])
#print(fxh2)
grad[idx] = (fxh1 - fxh2) / (2*h)
x[idx] = tmp_val #还原值
return np.around(grad,2)
def fun(x,y):
return x**2 + 2*x*y + y**2
x = np.array([1,2],dtype=np.float32)
y = np.array([3,4],dtype=np.float32)
numerical_gradient(fun,x,y)
array([ 8. , 11.99], dtype=float32)
线性回归的简洁实现
生成数据集
import numpy as np
import torch
from torch.utils import data
from d2l import torch as d2l
true_w = torch.tensor([2,-3.4])
true_b = 4.2
features, labels = d2l.synthetic_data(true_w,true_b,1000)
读取数据集
我们可以调用框架中现有的API来读取数据。 我们将features和labels作为API的参数传递，并通过数据迭代器指定batch_size。 此外，布尔值is_train表示是否希望数据迭代器对象在每个迭代周期内打乱数据。
def load_array(data_arrays,batch_size,is_train=True):
"""构造一个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)
next(iter(data_iter))
[tensor([[-1.7172],
[-0.3847],
[ 1.2882],
[ 1.0899],
[-0.4288],
[-0.7320],
[-0.9820],
[ 0.1833],
[-0.7348],
[-1.8271]]),
tensor([[6.6025],
[4.7402],
[2.4020],
[2.6759],
[4.7970],
[5.2199],
[5.5829],
[3.9453],
[5.2091],
[6.7485]])]
定义模型
当我们在6.2节中实现线性回归时， 我们明确定义了模型参数变量，并编写了计算的代码，这样通过基本的线性代数运算得到输出。 但是，如果模型变得更加复杂，且当我们几乎每天都需要实现模型时，自然会想简化这个过程。 这种情况类似于为自己的博客从零开始编写网页。 做一两次是有益的，但如果每个新博客就需要工程师花一个月的时间重新开始编写网页，那并不高效。
对于标准深度学习模型，我们可以使用框架的预定义好的层。这使我们只需关注使用哪些层来构造模型，而不必关注层的实现细节。 我们首先定义一个模型变量net，它是一个Sequential类的实例。 Sequential类将多个层串联在一起。 当给定输入数据时，Sequential实例将数据传入到第一层， 然后将第一层的输出作为第二层的输入，以此类推。 在下面的例子中，我们的模型只包含一个层，因此实际上不需要Sequential。 但是由于以后几乎所有的模型都是多层的，在这里使用Sequential会让你熟悉“标准的流水线”。
# nn是神经网络的缩写
from torch import nn
net = nn.Sequential(nn.Linear(2,1))
初始化模型参数
在使用net之前，我们需要初始化模型参数。 如在线性回归模型中的权重和偏置。 深度学习框架通常有预定义的方法来初始化参数。 在这里，我们指定每个权重参数应该从均值为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.])
定义损失函数
计算均方误差使用的是MSELoss类，也称为平方 L 2 L_2 L2范数。 默认情况下，它返回所有样本损失的平均值。
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}')
print(f'true:{[true_w,true_b]}, now:[{net[0].weight.data},{net[0].bias.data}]')
epoch 1, loss 0.000186
true:[tensor([ 2.0000, -3.4000]), 4.2], now:[tensor([[ 1.9960, -3.3939]]),tensor([4.1943])]
epoch 2, loss 0.000097
true:[tensor([ 2.0000, -3.4000]), 4.2], now:[tensor([[ 1.9995, -3.3995]]),tensor([4.2001])]
epoch 3, loss 0.000098
true:[tensor([ 2.0000, -3.4000]), 4.2], now:[tensor([[ 1.9992, -3.3999]]),tensor([4.2009])]
net[0].weight.grad
tensor([[0.0248, 0.0129]])
小结
一句话，牛批！！！真是怕我们多打一个字
练习
1.lr *= batch_size
- L 1 L_1 L1损失、CrossEntropyLoss、CTCLoss、NLLLoss、PoissonLoss等。
3.先对y进行backward()反向传播，再x.grad。上述对weight求梯度可以使用net[i].weight.grad访问权重集合的梯度
扫一扫
3130
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
