学习参考：

• 动手学深度学习2.0
• Deep-Learning-with-TensorFlow-book
• pytorchlightning

①如有冒犯、请联系侵删。
②已写完的笔记文章会不定时一直修订修改(删、改、增)，以达到集多方教程的精华于一文的目的。
③非常推荐上面（学习参考）的前两个教程，在网上是开源免费的，写的很棒，不管是开始学还是复习巩固都很不错的。

深度学习回顾，专栏内容来源多个书籍笔记、在线笔记、以及自己的感想、想法，佛系更新。争取内容全面而不失重点。完结时间到了也会一直更新下去，已写完的笔记文章会不定时一直修订修改(删、改、增)，以达到集多方教程的精华于一文的目的。所有文章涉及的教程都会写在开头、一起学习一起进步。

一、线性回归基本理论知识

1.线性回归的基本元素

回归（regression）是能为一个或多个自变量与因变量之间关系建模的一类方法。在机器学习领域中的大多数任务通常都与预测（prediction）有关。 当我们想预测一个数值时，就会涉及到回归问题。 常见的例子包括：预测价格（房屋、股票等）、预测住院时间（针对住院病人等）、 预测需求（零售销量等）。 但不是所有的预测都是回归问题。

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

为了解释线性回归，举一个实际的例子： 希望根据房屋的面积（平方英尺）和房龄（年）来估算房屋价格（美元）。 为了开发一个能预测房价的模型，需要收集一个真实的数据集。 这个数据集包括了房屋的销售价格、面积和房龄。 在机器学习的术语中，该数据集称为训练数据集（training data set） 或训练集（training set）。 每行数据（比如一次房屋交易相对应的数据）称为样本（sample）， 也可以称为数据点（data point）或数据样本（data instance）。 把试图预测的目标（比如预测房屋价格）称为标签（label）或目标（target）。 预测所依据的自变量（面积和房龄）称为特征（feature）或协变量

1.1线性模型

线性模型是一种用于建模和预测的数学模型，它基于自变量的线性组合来预测因变量的取值。线性模型的优点包括参数具有直观的解释性、易于理解和实现、计算效率高等。它们在统计学和机器学习中被广泛应用，例如线性回归、逻辑回归等。虽然线性模型假设自变量和因变量之间的关系是线性的，但在实际应用中，通过特征工程和模型改进可以处理许多非线性关系。

在机器学习领域，我们通常使用的是高维数据集，建模时采用线性代数表示法会比较方便。 当我们的输入包含 𝑑个特征时，我们将预测结果 𝑦̂ （通常使用“尖角”符号表示 𝑦 的估计值）表示为：

这个过程中的求和将使用广播机制。 给定训练数据特征 𝐗和对应的已知标签 𝐲 ， 线性回归的目标是找到一组权重向量 𝐰和偏置 𝑏 ： 当给定从 𝐗的同分布中取样的新样本特征时， 这组权重向量和偏置能够使得新样本预测标签的误差尽可能小。

1.2 损失函数

损失函数（loss function）能够量化目标的实际值与预测值之间的差距。 通常会选择非负数作为损失，且数值越小表示损失越小，完美预测时的损失为0。 回归问题中最常用的损失函数是平方误差函数。 当样本 𝑖 的预测值为 𝑦̂ (𝑖)，其相应的真实标签为 𝑦(𝑖) 时， 平方误差可以定义为以下公式：

常数 1/2 不会带来本质的差别，但这样在形式上稍微简单一些 （因为当对损失函数求导后常数系数为1）。 由于训练数据集并不受我们控制，所以经验误差只是关于模型参数的函数。

由于平方误差函数中的二次方项， 估计值 𝑦̂ (𝑖) 和观测值 𝑦(𝑖)之间较大的差异将导致更大的损失。 为了度量模型在整个数据集上的质量，需计算在训练集 𝑛个样本上的损失均值（也等价于求和）。

在训练模型时，我们希望寻找一组参数（ 𝐰∗,𝑏∗ ）， 这组参数能最小化在所有训练样本上的总损失。如下式：

1.3解析解

解析解：解析解是指通过数学方法直接求解出问题的解析表达式的方法。对于某些优化问题，存在一个闭式解，可以直接通过求导等数学运算得到最优解。例如，对于简单的线性回归模型，可以通过最小化残差平方和的方式，直接求解出最优的回归系数。但并不是所有的问题都存在解析解。

线性回归刚好是一个很简单的优化问题，线性回归的解可以用一个公式简单地表达出来， 这类解叫作解析解（analytical solution）。 首先，将偏置 𝑏 合并到参数 𝐰 中，合并方法是在包含所有参数的矩阵中附加一列。 预测问题是最小化 ‖𝐲−𝐗𝐰‖2 。 这在损失平面上只有一个临界点，这个临界点对应于整个区域的损失极小点。 将损失关于 𝐰 的导数设为0，得到解析解：

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

1.4 随机梯度下降

梯度下降：梯度下降是一种迭代优化算法，用于求解无法通过解析方法得到最优解的问题。它的基本思想是通过迭代的方式，沿着目标函数的负梯度方向逐步更新参数，以使目标函数逐渐收敛到最优解。梯度下降有多种变种，包括批量梯度下降（Batch Gradient Descent）、随机梯度下降（Stochastic Gradient Descent）和小批量梯度下降（Mini-batch Gradient Descent）等。

当优化问题存在解析解时，通常会优先选择解析解方法，因为它可以更快地得到最优解。但是对于复杂的非线性问题或无法直接求解的问题，梯度下降等迭代方法则是一种有效的求解方式。

梯度下降最简单的用法是计算损失函数（数据集中所有样本的损失均值） 关于模型参数的导数（在这里也可以称为梯度）。 但实际中的执行可能会非常慢：因为在每一次更新参数之前，必须遍历整个数据集。 因此，通常会在每次需要计算更新的时候随机抽取一小批样本， 这种变体叫做小批量随机梯度下降（minibatch stochastic gradient descent）。

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

算法的步骤如下：

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

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

上述公式中𝐰 和 𝐱都是向量。 在这里，更优雅的向量表示法比系数表示法（如 𝑤1,𝑤2,…,𝑤𝑑 ）更具可读性。 |B| 表示每个小批量中的样本数，这也称为批量大小（batch size）。 𝜂 表示学习率（learning rate）。 批量大小和学习率的值通常是手动预先指定，而不是通过模型训练得到的。 这些可以调整但不在训练过程中更新的参数称为超参数（hyperparameter）。 调参（hyperparameter tuning）是选择超参数的过程。 超参数通常是我们根据训练迭代结果来调整的， 而训练迭代结果是在独立的验证数据集（validation dataset）上评估得到的。

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

线性回归恰好是一个在整个域中只有一个最小值的学习问题。 但是对像深度神经网络这样复杂的模型来说，损失平面上通常包含多个最小值。 深度学习实践者很少会去花费大力气寻找这样一组参数，使得在训练集上的损失达到最小。 事实上，更难做到的是找到一组参数，这组参数能够在从未见过的数据上实现较低的损失， 这一挑战被称为泛化（generalization）。

2.矢量化加速

在训练模型时，经常希望能够同时处理整个小批量的样本。 为了实现这一点，需要对计算进行矢量化， 从而利用线性代数库，而不是在Python中编写开销高昂的for循环。

为了说明矢量化为什么如此重要，考虑(对向量相加的两种方法)。 实例化两个全为1的10000维向量。 在一种方法中，将使用Python的for循环遍历向量； 在另一种方法中，我们将依赖对+的调用。

%matplotlib inline
import math
import time
import numpy as np
import tensorflow as tf
from d2l import tensorflow as d2l

class Timer:  #@save
    """记录多次运行时间"""
    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 sum(self):
        """返回时间总和"""
        return sum(self.times)

    def cumsum(self):
        """返回累计时间"""
        return np.array(self.times).cumsum().tolist()

n = 10000
a = tf.ones([n])
b = tf.ones([n])

c = tf.Variable(tf.zeros(n))
print(c)

<tf.Variable 'Variable:0' shape=(10000,) dtype=float32, numpy=array([0., 0., 0., ..., 0., 0., 0.], dtype=float32)>

首先，使用for循环，每次执行一位的加法，查看所花费的时间：

timer = Timer()
for i in range(n):
    c[i].assign(a[i] + b[i])
print(c)
f'{timer.stop():.5f} sec'

<tf.Variable 'Variable:0' shape=(10000,) dtype=float32, numpy=array([2., 2., 2., ..., 2., 2., 2.], dtype=float32)>
'11.96324 sec'

使用重载的+运算符来计算按元素的和，并查看所花费的时间：

timer.start()
d = a + b
print(d)
f'{timer.stop():.5f} sec'

tf.Tensor([2. 2. 2. ... 2. 2. 2.], shape=(10000,), dtype=float32)
'0.00401 sec'

第二种方法比第一种方法快得多。 矢量化代码通常会带来数量级的加速。

3.正态分布与平方损失

通过对噪声分布的假设来解读平方损失目标函数。正态分布和线性回归之间的关系很密切。 正态分布（normal distribution），也称为高斯分布（Gaussian distribution）。
简单的说，若随机变量 𝑥具有均值 𝜇 和方差 𝜎² （标准差 𝜎 ），其正态分布概率密度函数如下：

对正太分布进行可视化，可以发现改变均值会产生沿 𝑥 轴的偏移，增加方差将会分散分布、降低其峰值。

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-u中，现在可以写出通过给定的 𝐱 观测到特定 𝑦 的似然（likelihood）：

现在，根据极大似然估计法，参数 𝐰 和 𝑏 的最优值是使整个数据集的似然最大的值：

化通常是说最小化而不是最大化。 可以改为最小化负对数似然 −log𝑃(𝐲∣𝐗) 。 由此可以得到的数学公式是：

现在只需要假设 𝜎 是某个固定常数就可以忽略第一项， 因为第一项不依赖于 𝐰 和 𝑏 。 现在第二项除了常数 1/𝜎²外，其余部分和前面介绍的均方误差是一样的。 幸运的是，上面式子的解并不依赖于 𝜎 。 因此，在高斯噪声的假设下，最小化均方误差等价于对线性模型的极大似然估计。

4.从线性回归到深度网络

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

输入为 𝑥1,…,𝑥𝑑 ， 因此输入层中的输入数（或称为特征维度，feature dimensionality）为 𝑑 。 网络的输出为 𝑜1 ，因此输出层中的输出数是1。 需要注意的是，输入值都是已经给定的，并且只有一个计算神经元。 由于模型重点在发生计算的地方，所以通常在计算层数时不考虑输入层。 将线性回归模型视为仅由单个人工神经元组成的神经网络，或称为单层神经网络。

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

二、从0开始实现线性回归

从零开始实现整个方法， 包括数据流水线、模型、损失函数和小批量随机梯度下降优化器)。

%matplotlib inline
import random
import tensorflow as tf
from d2l import tensorflow as d2l

1.加载数据集

（1）生成数据集

为了简单起见，将根据带有噪声的线性模型构造一个人造数据集。任务是使用这个有限样本的数据集来恢复这个模型的参数。 使用低维数据，这样可以很容易地将其可视化。

𝜖可以视为模型预测和标签时的潜在观测误差。 在这里认为标准假设成立，即 𝜖 服从均值为0的正态分布。 为了简化问题，将标准差设为0.01。注意，features中的每一行都包含一个二维数据样本， labels中的每一行都包含一维标签值（一个标量）。

def synthetic_data(w, b, num_examples):  #@save
    """生成y=Xw+b+噪声"""
    X = tf.zeros((num_examples, w.shape[0]))
    X += tf.random.normal(shape=X.shape)
    y = tf.matmul(X, tf.reshape(w, (-1, 1))) + b
    y += tf.random.normal(shape=y.shape, stddev=0.01)
    y = tf.reshape(y, (-1, 1))
    return X, y

true_w = tf.constant([2, -3.4])
true_b = 4.2
features, labels = synthetic_data(true_w, true_b, 1000)
print('features:', features[0],'\nlabel:', labels[0])
# 通过生成第二个特征features[:, 1]和labels的散点图， 可以直观观察到两者之间的线性关系。
d2l.set_figsize()
d2l.plt.scatter(features[:, 1].numpy(), labels.numpy(), 1);

（2）读取数据集

训练模型时要对数据集进行遍历，每次抽取一小批量样本，并使用它们来更新模型。 由于这个过程是训练机器学习算法的基础，所以有必要定义一个函数， 该函数能打乱数据集中的样本并以小批量方式获取数据。

定义一个data_iter函数， 该函数接收批量大小、特征矩阵和标签向量作为输入，生成大小为batch_size的小批量。 每个小批量包含一组特征和标签。通常，利用GPU并行运算的优势，处理合理大小的“小批量”。 每个样本都可以并行地进行模型计算，且每个样本损失函数的梯度也可以被并行计算。 GPU可以在处理几百个样本时，所花费的时间不比处理一个样本时多太多。

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):
        j = tf.constant(indices[i: min(i + batch_size, num_examples)])
        yield tf.gather(features, j), tf.gather(labels, j)

该如何使用这个data_iter函数读取数据呢？示例如下：batch_size = 10代表读取的数据批次中批次大小为10、即一个批次包含10个样本（1个样本中包含2个特征值和1个标签值）。

batch_size = 10

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

tf.Tensor(
[[-2.8630428  -1.7284393 ]
 [-0.2553304  -0.3009327 ]
 [-0.931128    0.8339995 ]
 [ 1.2098598  -0.9016074 ]
 [ 0.4295501  -0.8999548 ]
 [-1.2770212   0.63788086]
 [-2.2767484   0.7082932 ]
 [-0.82348746  1.1758038 ]
 [-0.03394526  0.32371238]
 [ 0.5636274   2.1109307 ]], shape=(10, 2), dtype=float32) 
 tf.Tensor(
[[ 4.3342004 ]
 [ 4.704773  ]
 [-0.49631497]
 [ 9.697074  ]
 [ 8.11423   ]
 [-0.5196032 ]
 [-2.7675097 ]
 [-1.4500179 ]
 [ 3.0524535 ]
 [-1.8642615 ]], shape=(10, 1), dtype=float32)

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

2.初始化模型参数

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

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

w = tf.Variable(tf.random.normal(shape=(2, 1), mean=0, stddev=0.01),
                trainable=True)
b = tf.Variable(tf.zeros(1), trainable=True)

3.定义模型

定义模型，将模型的输入和参数同模型的输出关联起来。要计算线性模型的输出， 只需计算输入特征 𝐗 和模型权重 𝐰 的矩阵-向量乘法后加上偏置 𝑏 。 注意， 𝐗𝐰 是一个向量，而 𝑏 是一个标量。

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

4.定义损失函数

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

5.定义优化算法

尽管线性回归有解析解，但很多其他模型却没有。 所以这里使用小批量随机梯度下降。

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

def sgd(params, grads, lr, batch_size):  #@save
    """小批量随机梯度下降"""
    for param, grad in zip(params, grads):
        param.assign_sub(lr*grad/batch_size)

6.训练

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

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

在每个迭代周期（epoch）中，使用data_iter函数遍历整个数据集， 并将训练数据集中所有样本都使用一次（假设样本数能够被批量大小整除）。 这里的迭代周期个数num_epochs和学习率lr都是超参数，分别设为3和0.03。 设置超参数很棘手，需要通过反复试验进行调整。

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):
        with tf.GradientTape() as g:
            l = loss(net(X, w, b), y)  # X和y的小批量损失
        # 计算l关于[w,b]的梯度
        dw, db = g.gradient(l, [w, b])
        # 使用参数的梯度更新参数
        sgd([w, b], [dw, db], lr, batch_size)
    train_l = loss(net(features, w, b), labels)
    print(f'epoch {epoch + 1}, loss {float(tf.reduce_mean(train_l)):f}')

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

print("true_w：{};\t predict_w：{}".format(true_w,tf.reshape(w, true_w.shape)))
print("true_b：{};\t predict_b：{}".format(true_b,b))

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

true_w：[ 2.  -3.4];	 predict_w：[ 2.0002403 -3.3986738]
true_b：4.2;	 predict_b：<tf.Variable 'Variable:0' shape=(1,) dtype=float32, numpy=array([4.198851], dtype=float32)>
w的估计误差: [-0.00024033 -0.00132632]
b的估计误差: [0.0011487]

三、使用tf2.x框架实现线性回归

1.生成与读取数据集

import numpy as np
import tensorflow as tf
from d2l import tensorflow as d2l

true_w = tf.constant([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):  #@save
    """构造一个TensorFlow数据迭代器"""
    dataset = tf.data.Dataset.from_tensor_slices(data_arrays)
    if is_train:
        dataset = dataset.shuffle(buffer_size=1000)
    dataset = dataset.batch(batch_size)
    return dataset

batch_size = 10
data_iter = load_array((features, labels), batch_size)

使用iter构造Python迭代器，并使用next从迭代器中获取第一项查看一下数据：

next(iter(data_iter))

(<tf.Tensor: shape=(10, 2), dtype=float32, numpy=
 array([[ 0.7549312 ,  1.1634187 ],
        [-0.9076974 ,  0.294394  ],
        [ 0.79255503,  0.5334212 ],
        [-0.47842976, -0.356793  ],
        [-2.4618537 , -1.1869135 ],
        [ 0.05317755,  0.9800634 ],
        [-0.7289027 ,  1.8825058 ],
        [ 0.40069494, -0.76551396],
        [-1.3978626 ,  0.80886126],
        [ 0.40911174, -1.949414  ]], dtype=float32)>,
 <tf.Tensor: shape=(10, 1), dtype=float32, numpy=
 array([[ 1.7705692],
        [ 1.4039987],
        [ 3.9656024],
        [ 4.480841 ],
        [ 3.3081772],
        [ 0.9686907],
        [-3.6616247],
        [ 7.6049724],
        [-1.3391331],
        [11.641719 ]], dtype=float32)>)

2.定义模型

对于标准深度学习模型，可以使用框架的预定义好的层。只需关注使用哪些层来构造模型，而不必关注层的实现细节。

首先定义一个模型变量net，它是一个Sequential类的实例。 Sequential类将多个层串联在一起。 当给定输入数据时，Sequential实例将数据传入到第一层， 然后将第一层的输出作为第二层的输入，以此类推。值得注意的是，为了方便使用，Keras不要求必须为每个层指定输入形状。 所以在这里，不需要告诉Keras有多少输入进入这一层。

# keras是TensorFlow的高级API
net = tf.keras.Sequential()
net.add(tf.keras.layers.Dense(1))

3.初始化模型参数

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

TensorFlow中的initializers模块提供了多种模型参数初始化方法。 在Keras中最简单的指定初始化方法是在创建层时指定kernel_initializer。在这里，重新创建了net并指定kernel_initializer的值进行参数初始化。

initializer = tf.initializers.RandomNormal(stddev=0.01)
net = tf.keras.Sequential()
net.add(tf.keras.layers.Dense(1, kernel_initializer=initializer))

4.定义损失函数

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

loss = tf.keras.losses.MeanSquaredError()

5.定义优化算法

小批量随机梯度下降算法是一种优化神经网络的标准工具， Keras在optimizers模块中实现了该算法的许多变种。 小批量随机梯度下降只需要设置learning_rate值，这里设置为0.03。

trainer = tf.keras.optimizers.SGD(learning_rate=0.03)

6.训练

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

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

1. 通过调用net(X)生成预测并计算损失l（前向传播）。
2. 通过进行反向传播来计算梯度。
3. 通过调用优化器来更新模型参数。

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

num_epochs = 3
for epoch in range(num_epochs):
    for X, y in data_iter:
        with tf.GradientTape() as tape:
            l = loss(net(X, training=True), y)
        grads = tape.gradient(l, net.trainable_variables)
        trainer.apply_gradients(zip(grads, net.trainable_variables))
    l = loss(net(features), labels)
    print(f'epoch {epoch + 1}, loss {l:f}')

epoch 1, loss 0.000270
epoch 2, loss 0.000102
epoch 3, loss 0.000102

比较生成数据集的真实参数和通过有限数据训练获得的模型参数。 要访问参数，首先从net访问所需的层，然后读取该层的权重和偏置。

w = net.get_weights()[0]
print("true_w：{};\t predict_w：{}".format(true_w,tf.reshape(w, true_w.shape)))
print('w的估计误差：', true_w - tf.reshape(w, true_w.shape))

b = net.get_weights()[1]
print("true_b：{};\t predict_b：{}".format(true_b,b))
print('b的估计误差：', true_b - b)

true_w：[ 2.  -3.4];	 predict_w：[ 1.9997835 -3.4006681]
w的估计误差： tf.Tensor([0.00021648 0.00066805], shape=(2,), dtype=float32)
true_b：4.2;	 predict_b：[4.200885]
b的估计误差： [-0.00088501]