目录

• 为什么选择TensorFlow和Keras？
• 环境准备与安装
• TensorFlow基础：理解核心概念
  • 张量（Tensor）
  • 变量（Variable）
  • 计算图与即时执行
  • 自动微分
• Keras模型构建：两种主要方式
  • Sequential API：线性堆叠模型
  • Functional API：更灵活的模型构建
• 模型编译：准备训练
• 模型训练：学习过程
• 模型评估：检验效果
• 模型保存与加载：持久化你的成果
• 实战案例：MNIST手写数字识别
• 进阶技巧与最佳实践
  • 1. 使用TensorBoard进行可视化
  • 2. 数据增强
  • 3. 迁移学习
  • 4. 学习率调度器
• 总结与展望

---

在人工智能浪潮席卷全球的今天，深度学习无疑是最耀眼的明星。它驱动着图像识别、自然语言处理、智能推荐等领域的飞速发展，深刻地改变着我们的生活。我希望通过这篇文章，带你走进深度学习的世界，用TensorFlow和Keras构建你的第一个深度学习模型，开启你的AI探索之旅。

为什么选择TensorFlow和Keras？

TensorFlow，这个由Google Brain团队打造的开源深度学习框架，早已成为业界的标杆。而Keras，则是一个以用户友好性著称的高级神经网络API，它可以运行在TensorFlow、CNTK或Theano等后端之上。自TensorFlow 2.0起，Keras被正式纳入TensorFlow的怀抱，成为其官方推荐的高级API。

选择TensorFlow/Keras，你将拥有：

• 强大的社区支持与完善的文档: 遇到问题？庞大的社区和详尽的文档是你最坚实的后盾。
• 灵活的模型构建方式: 无论是快速原型验证还是复杂模型构建，TensorFlow/Keras都能满足你的需求。
• 优秀的可视化工具 (TensorBoard): 告别黑箱，TensorBoard助你洞察模型训练的每一个细节。
• 便捷的部署能力，跨平台支持: 从移动端到服务器，你的模型可以无处不在。
• 海量的预训练模型: 站在巨人的肩膀上，事半功倍。

准备好了吗？让我们一起深入TensorFlow/Keras的世界，开始你的深度学习之旅！

环境准备与安装

工欲善其事，必先利其器。首先，我们需要搭建好TensorFlow的开发环境。推荐使用Python的虚拟环境，它可以帮助我们隔离不同项目的依赖，避免环境污染。

# 创建虚拟环境（推荐）
python -m venv tf_env
source tf_env/bin/activate  # Linux/Mac
# 或 tf_env\Scripts\activate  # Windows

# 安装TensorFlow
pip install tensorflow

安装完成后，验证一下TensorFlow是否成功安装：

import tensorflow as tf
print("TensorFlow 版本:", tf.__version__)

如果你的电脑配备了NVIDIA显卡，强烈建议安装支持GPU加速的TensorFlow版本，这将大大提升模型训练的速度。具体安装步骤可以参考TensorFlow官方文档。

TensorFlow基础：理解核心概念

TensorFlow之所以强大，离不开其背后一系列核心概念的支撑。理解这些概念，是掌握TensorFlow的关键。

张量（Tensor）

张量是TensorFlow世界里的基本数据单元，你可以把它看作是多维数组的泛化。从零维的标量，到一维的向量，再到二维的矩阵，乃至更高维度的数据结构，都可以用张量来表示。

import tensorflow as tf

# 创建不同维度的张量
scalar = tf.constant(42)                       # 标量（0维）
vector = tf.constant([1, 2, 3, 4])             # 向量（1维）
matrix = tf.constant([[1, 2], [3, 4]])         # 矩阵（2维）
tensor_3d = tf.constant([[[1, 2], [3, 4]]])    # 3维张量

print("标量形状:", scalar.shape)
print("向量形状:", vector.shape)
print("矩阵形状:", matrix.shape)
print("3维张量形状:", tensor_3d.shape)

代码解释:

这段代码演示了如何使用 tf.constant() 创建不同维度的张量。shape 属性可以查看张量的形状，它描述了张量在每个维度上的大小。

变量（Variable）

变量是TensorFlow中可以被修改的张量，它通常用来存储模型的权重和偏置等参数。在模型训练过程中，变量的值会不断更新，以优化模型性能。

# 创建变量
weights = tf.Variable([[1.0, 2.0], [3.0, 4.0]])
bias = tf.Variable([0.1, 0.2])

# 更新变量
weights.assign(weights * 2)
print("更新后的权重:\n", weights.numpy())

代码解释:

tf.Variable() 用于创建变量。assign() 方法可以用来更新变量的值。numpy() 方法可以将TensorFlow张量转换为NumPy数组，方便打印和查看。

计算图与即时执行

TensorFlow 2.x 默认采用即时执行 (Eager Execution) 模式。这意味着代码会像普通的Python代码一样逐行执行，方便调试和理解。

# 即时执行模式
x = tf.constant([[1, 2], [3, 4]])
y = tf.constant([[5, 6], [7, 8]])

# 直接执行运算
z = tf.matmul(x, y)
print("矩阵乘法结果:\n", z.numpy())

代码解释:

这段代码直接执行了矩阵乘法 tf.matmul(x, y)，并立即打印了结果。这就是即时执行的特点：操作立即执行，结果立即可见。

虽然即时执行很方便，但在某些场景下，使用计算图 (Graph) 可以获得更好的性能。计算图是一种预先定义好的计算流程，TensorFlow可以对其进行优化，提高运行效率。

# 使用 @tf.function 创建计算图
@tf.function
def compute_z(x, y):
    return tf.matmul(x, y)

result = compute_z(x, y)
print("通过计算图计算的结果:\n", result.numpy())

代码解释:

@tf.function 装饰器可以将Python函数转换为TensorFlow计算图。被装饰的函数在首次调用时会被编译成图，后续调用将直接执行优化后的图，从而提升性能。

自动微分

自动微分是深度学习框架的核心技能。它能够自动计算函数的梯度，而梯度正是模型优化的关键。TensorFlow使用 tf.GradientTape 来记录操作，并计算梯度。

# 使用 GradientTape 进行自动微分
x = tf.Variable(3.0)

with tf.GradientTape() as tape:
    y = x**2  # y = x^2

# 计算 dy/dx
dy_dx = tape.gradient(y, x)
print("dy/dx at x=3:", dy_dx.numpy())  # 应该是 6，因为 d(x^2)/dx = 2x

代码解释:

tf.GradientTape() 创建一个梯度记录器。在 with 语句块中执行的操作会被记录下来。tape.gradient(y, x) 计算 y 对 x 的梯度。

Keras模型构建：两种主要方式

Keras提供了两种主要的API来构建神经网络模型：Sequential API 和 Functional API。

Sequential API：线性堆叠模型

Sequential API 是构建线性堆叠模型的利器。它就像搭积木一样，一层一层地添加神经网络层。

from tensorflow import keras
from tensorflow.keras import layers

# 使用 Sequential API 构建一个简单的多层感知机
model = keras.Sequential([
    layers.Dense(128, activation='relu', input_shape=(784,)), # 输入层 + 全连接层 (128个神经元，ReLU激活函数)
    layers.Dropout(0.2),                                      # Dropout层 (防止过拟合)
    layers.Dense(64, activation='relu'),                       # 全连接层 (64个神经元，ReLU激活函数)
    layers.Dropout(0.2),                                      # Dropout层
    layers.Dense(10, activation='softmax')                     # 输出层 (10个神经元，Softmax激活函数，用于多分类)
])

# 查看模型结构
model.summary()

代码解释:

• keras.Sequential() 创建一个序贯模型。
• layers.Dense() 添加全连接层。 input_shape 参数只在第一层需要指定输入形状。 activation 参数指定激活函数，例如 ‘relu’ (ReLU激活函数) 和 ‘softmax’ (Softmax激活函数)。
• layers.Dropout(0.2) 添加 Dropout 层，随机丢弃一部分神经元，防止过拟合。
• model.summary() 打印模型结构，包括每一层的类型、输出形状和参数数量。

系统架构图 (Mermaid):

Functional API：更灵活的模型构建

Functional API 提供了更大的灵活性，可以构建更复杂的模型，例如多输入多输出模型、共享层模型等。

# 使用 Functional API 构建相同的模型
inputs = keras.Input(shape=(784,))                      # 定义输入层
x = layers.Dense(128, activation='relu')(inputs)      # 全连接层，输入为 inputs
x = layers.Dropout(0.2)(x)
x = layers.Dense(64, activation='relu')(x)
x = layers.Dropout(0.2)(x)
outputs = layers.Dense(10, activation='softmax')(x)    # 输出层，输入为 x

model = keras.Model(inputs=inputs, outputs=outputs)     # 创建模型，指定输入和输出

# 查看模型结构
model.summary()

代码解释:

• keras.Input(shape=(784,)) 定义输入层，指定输入形状。
• 函数式API 的每一层都像一个函数一样被调用，并将上一层的输出作为输入。例如 layers.Dense(128, activation='relu')(inputs) 表示创建一个全连接层，输入是 inputs 张量。
• keras.Model(inputs=inputs, outputs=outputs) 创建模型，需要显式指定模型的输入和输出。

系统架构图 (Mermaid):

模型编译：准备训练

模型构建完成后，需要进行编译。编译模型主要包括指定优化器、损失函数和评估指标。

model.compile(
    optimizer='adam',               # 优化器：Adam优化器
    loss='categorical_crossentropy', # 损失函数：交叉熵损失 (适用于多分类)
    metrics=['accuracy']             # 评估指标：准确率
)

代码解释:

• optimizer='adam' 选择 Adam 优化器。Adam 是一种常用的优化算法，它结合了动量和自适应学习率的优点。
• loss='categorical_crossentropy' 选择交叉熵损失函数。交叉熵损失常用于多分类问题。
• metrics=['accuracy'] 指定评估指标为准确率。在训练过程中，模型会同时计算并显示准确率。

常用的优化器:

• adam: Adam优化器，通用性强，效果好。
• sgd: 随机梯度下降优化器，可以设置动量 (momentum)。
• rmsprop: RMSprop优化器，适用于循环神经网络 (RNN) 等。

常用的损失函数:

• categorical_crossentropy: 分类交叉熵损失，用于多分类问题。
• binary_crossentropy: 二元交叉熵损失，用于二分类问题。
• mse (mean squared error): 均方误差损失，用于回归问题。

模型训练：学习过程

模型编译完成后，就可以使用训练数据对模型进行训练了。训练过程的目标是让模型学习到数据中的模式，并不断调整模型参数，以最小化损失函数。

history = model.fit(
    x_train, y_train,           # 训练数据和标签
    batch_size=128,             # 批次大小：每次训练使用 128 个样本
    epochs=10,                  # 训练轮数：训练 10 轮
    validation_split=0.2        # 验证集比例：使用 20% 的训练数据作为验证集
)

代码解释:

• model.fit() 开始模型训练。
• x_train, y_train 训练数据和对应的标签。
• batch_size=128 设置批次大小。将训练数据分成小批次进行训练，可以提高训练效率和稳定性。
• epochs=10 设置训练轮数。一轮 (epoch) 指的是完整遍历一遍训练数据集。
• validation_split=0.2 从训练集中划分出 20% 的数据作为验证集。模型在每个 epoch 结束后会在验证集上评估性能。

model.fit() 函数会返回一个 history 对象，它记录了训练过程中的各种指标，例如损失值和准确率。我们可以使用 history 对象来可视化训练过程。

import matplotlib.pyplot as plt

# 绘制训练和验证准确率
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='训练准确率')
plt.plot(history.history['val_accuracy'], label='验证准确率')
plt.xlabel('Epoch')
plt.ylabel('准确率')
plt.legend()

# 绘制训练和验证损失
plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='训练损失')
plt.plot(history.history['val_loss'], label='验证损失')
plt.plot(history.history['val_loss'], label='验证损失')
plt.xlabel('Epoch')
plt.ylabel('损失')
plt.legend()

plt.show()

代码解释:

这段代码使用 matplotlib 库绘制了训练过程中的准确率和损失值曲线。通过观察这些曲线，我们可以了解模型的训练情况，例如是否过拟合、是否收敛等。

模型训练流程图 (Mermaid):

模型评估：检验效果

模型训练完成后，我们需要在测试集上评估模型的性能，检验模型的泛化能力。

test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"测试准确率: {test_acc:.4f}")

代码解释:

model.evaluate(x_test, y_test) 在测试集 (x_test, y_test) 上评估模型性能，并返回测试损失值和测试准确率。

对于分类问题，混淆矩阵 (Confusion Matrix) 是一种非常有用的评估工具，它可以帮助我们更深入地了解模型的分类结果。

import numpy as np
from sklearn.metrics import confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt # 确保 plt 已经导入

# 获取预测结果
y_pred = model.predict(x_test)
y_pred_classes = np.argmax(y_pred, axis=1) # 将 one-hot 编码转换为类别标签
y_true = np.argmax(y_test, axis=1)       # 将 one-hot 编码转换为类别标签

# 生成混淆矩阵
conf_matrix = confusion_matrix(y_true, y_pred_classes)

# 可视化混淆矩阵
plt.figure(figsize=(10, 8))
sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues') # 使用 seaborn 绘制热力图
plt.xlabel('预测标签')
plt.ylabel('真实标签')
plt.title('混淆矩阵')
plt.show()

代码解释:

• model.predict(x_test) 使用模型对测试集进行预测，返回预测结果 (概率分布)。
• np.argmax(y_pred, axis=1) 将预测的概率分布转换为类别标签。
• confusion_matrix(y_true, y_pred_classes) 计算混淆矩阵。
• sns.heatmap() 使用 seaborn 库可视化混淆矩阵，颜色越深表示数值越大。

模型保存与加载：持久化你的成果

训练好的模型可以保存到磁盘上，方便以后加载和使用。Keras 提供了多种模型保存方式。

# 保存整个模型（包括架构、权重和编译信息）
model.save('my_model.h5')

# 仅保存模型权重
model.save_weights('model_weights.h5')

# 加载整个模型
loaded_model = keras.models.load_model('my_model.h5')

# 加载权重到相同结构的模型
model.load_weights('model_weights.h5')

代码解释:

• model.save('my_model.h5') 将整个模型保存为 H5 文件格式。H5 文件包含了模型的架构、权重以及编译信息。
• model.save_weights('model_weights.h5') 仅保存模型的权重。这种方式保存的文件体积更小，但加载时需要先构建相同的模型结构，再加载权重。
• keras.models.load_model('my_model.h5') 加载保存的完整模型。
• model.load_weights('model_weights.h5') 加载保存的模型权重。

TensorFlow 2.x 还推荐使用 SavedModel 格式，它更适合生产环境部署。

# 保存为 SavedModel 格式
model.save('saved_model_dir')

# 加载 SavedModel
loaded_model = tf.keras.models.load_model('saved_model_dir')

代码解释:

• model.save('saved_model_dir') 将模型保存为 SavedModel 格式，保存到 saved_model_dir 目录下。SavedModel 格式包含了模型的计算图和变量，更方便跨平台部署。
• tf.keras.models.load_model('saved_model_dir') 加载 SavedModel 格式的模型。

实战案例：MNIST手写数字识别

理论学习了这么多，是时候来一场实战演练了！我们选择经典的 MNIST 手写数字识别任务，来综合运用前面学到的知识。

MNIST 数据集包含了 70,000 张 28x28 像素的手写数字图像，分为 60,000 张训练图像和 10,000 张测试图像，共 10 个类别 (0-9)。

import tensorflow as tf
from tensorflow import keras
import numpy as np
import matplotlib.pyplot as plt

# 1. 加载 MNIST 数据集
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# 2. 数据预处理
# 将像素值归一化到 [0, 1] 区间
x_train = x_train.astype("float32") / 255.0
x_test = x_test.astype("float32") / 255.0

# 将图像展平为一维向量 (28x28 -> 784)
x_train = x_train.reshape(-1, 28*28)
x_test = x_test.reshape(-1, 28*28)

# 将标签转换为 one-hot 编码 (例如： 5 -> [0, 0, 0, 0, 0, 1, 0, 0, 0, 0])
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)

# 3. 创建模型 (使用 Sequential API)
model = keras.Sequential([
    keras.layers.Dense(128, activation='relu', input_shape=(784,)),
    keras.layers.BatchNormalization(), # 批量归一化层
    keras.layers.Dropout(0.3),
    keras.layers.Dense(64, activation='relu'),
    keras.layers.BatchNormalization(), # 批量归一化层
    keras.layers.Dropout(0.3),
    keras.layers.Dense(10, activation='softmax')
])

# 4. 编译模型
model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=0.001), # Adam 优化器，学习率设置为 0.001
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

# 5. 定义回调函数 (Callbacks)
callbacks = [
    keras.callbacks.EarlyStopping(     # EarlyStopping 回调函数
        patience=5,                   # 当验证集损失连续 5 个 epoch 没有下降时，提前停止训练
        monitor='val_loss',           # 监控指标为验证集损失
        restore_best_weights=True      # 恢复模型在验证集上表现最佳的权重
    ),
    keras.callbacks.ReduceLROnPlateau( # ReduceLROnPlateau 回调函数
        factor=0.5,                   # 当验证集损失不再下降时，学习率缩小为原来的 0.5 倍
        patience=3,                   # 当验证集损失连续 3 个 epoch 没有下降时，降低学习率
        monitor='val_loss'            # 监控指标为验证集损失
    )
]

# 6. 训练模型
history = model.fit(
    x_train, y_train,
    batch_size=128,
    epochs=20,
    validation_split=0.1,           # 使用 10% 的训练数据作为验证集
    callbacks=callbacks,            # 使用定义的回调函数
    verbose=1                       # 显示训练过程信息
)

# 7. 评估模型
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"测试准确率: {test_acc:.4f}")

# 8. 可视化训练过程 (与前面代码相同，此处省略)
# ... (代码与前面的可视化训练过程代码相同) ...
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='训练准确率')
plt.plot(history.history['val_accuracy'], label='验证准确率')
plt.xlabel('Epoch')
plt.ylabel('准确率')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='训练损失')
plt.plot(history.history['val_loss'], label='验证损失')
plt.xlabel('Epoch')
plt.ylabel('损失')
plt.legend()
plt.show()


# 9. 可视化预测结果
def plot_predictions(model, x_test, y_test, n=5):
    # 获取预测结果
    predictions = model.predict(x_test[:n])
    pred_classes = np.argmax(predictions, axis=1)
    true_classes = np.argmax(y_test[:n], axis=1)

    plt.figure(figsize=(15, 3))
    for i in range(n):
        plt.subplot(1, n, i+1)
        plt.imshow(x_test[i].reshape(28, 28), cmap='gray') # 显示图像
        color = 'green' if pred_classes[i] == true_classes[i] else 'red' # 预测正确为绿色，错误为红色
        plt.title(f"预测: {pred_classes[i]}\n真实: {true_classes[i]}", color=color) # 显示预测和真实标签
        plt.axis('off') # 关闭坐标轴
    plt.show()

plot_predictions(model, x_test, y_test, 10) # 显示 10 个预测结果

# 10. 保存模型
model.save('mnist_model.h5')

代码解释 (MNIST 案例):

• 数据加载与预处理: 加载 MNIST 数据集，并将像素值归一化到 [0, 1] 区间，将图像展平为一维向量，将标签转换为 one-hot 编码。
• 模型构建: 使用 Sequential API 构建多层感知机模型，加入了 批量归一化 (Batch Normalization) 层和 Dropout 层。
  • 批量归一化: 加速训练，提高模型稳定性。
  • Dropout: 防止过拟合。
• 模型编译: 使用 Adam 优化器，交叉熵损失函数，评估指标为准确率。
• 回调函数: 使用了 EarlyStopping 和 ReduceLROnPlateau 回调函数，用于提前停止训练和动态调整学习率。
• 模型训练与评估: 使用 model.fit() 训练模型，使用 model.evaluate() 评估模型性能。
• 可视化预测结果: plot_predictions 函数用于可视化模型对测试集中前 N 个样本的预测结果，方便直观地了解模型的表现。

进阶技巧与最佳实践

掌握了基本操作后，下面介绍一些进阶技巧，助你更上一层楼。

1. 使用 TensorBoard 进行可视化

TensorBoard 是 TensorFlow 自带的可视化工具，它可以帮助你监控训练过程，分析模型性能。

import datetime

# 添加 TensorBoard 回调
log_dir = "logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = tf.keras.callbacks.TensorBoard(
    log_dir=log_dir, histogram_freq=1 # 记录直方图频率
)

# 在训练时使用该回调
history = model.fit(
    x_train, y_train,
    epochs=10,
    validation_split=0.2,
    callbacks=[tensorboard_callback] # 添加 TensorBoard 回调
)

然后在命令行中运行：

tensorboard --logdir=logs/fit

打开浏览器，访问 TensorBoard 提供的地址，即可查看训练过程中的各种指标，例如损失值、准确率、权重分布等。

2. 数据增强

数据增强 (Data Augmentation) 是一种常用的技巧，可以增加训练数据的多样性，提高模型的泛化能力。对于图像数据，常用的数据增强方法包括随机翻转、随机旋转、随机缩放等。

data_augmentation = keras.Sequential([
    layers.experimental.preprocessing.RandomFlip("horizontal"), # 随机水平翻转
    layers.experimental.preprocessing.RandomRotation(0.1),    # 随机旋转 (最大旋转角度为 0.1 * 2pi)
    layers.experimental.preprocessing.RandomZoom(0.1),       # 随机缩放 (缩放比例范围为 [1-0.1, 1+0.1])
])

# 在模型中使用数据增强
inputs = keras.Input(shape=(32, 32, 3)) # 假设输入图像形状为 (32, 32, 3)
x = data_augmentation(inputs)           # 应用数据增强
# ... 后续层 ...

代码解释:

• layers.experimental.preprocessing.RandomFlip("horizontal"), RandomRotation(0.1), RandomZoom(0.1) 创建数据增强层。
• 数据增强层可以像普通层一样添加到模型中，在模型训练时，数据增强层会在输入数据上随机应用各种变换。

3. 迁移学习

迁移学习 (Transfer Learning) 是一种强大的技术，它可以利用预训练模型在新的任务上快速取得良好的效果。特别是当训练数据较少时，迁移学习尤为有效。

base_model = keras.applications.MobileNetV2( # 加载 MobileNetV2 预训练模型
    weights='imagenet',  # 加载在 ImageNet 数据集上预训练的权重
    include_top=False,   # 不包括顶层分类器 (全连接层)
    input_shape=(224, 224, 3) # 输入图像形状
)

# 冻结基础模型 (不训练基础模型的权重)
base_model.trainable = False

# 添加自定义头部 (分类器)
model = keras.Sequential([
    base_model,
    layers.GlobalAveragePooling2D(), # 全局平均池化层
    layers.Dense(128, activation='relu'),
    layers.Dense(num_classes, activation='softmax') # num_classes 为新任务的类别数
])

代码解释:

• keras.applications.MobileNetV2(weights='imagenet', include_top=False, input_shape=(224, 224, 3)) 加载预训练的 MobileNetV2 模型。weights='imagenet' 表示加载在 ImageNet 数据集上预训练的权重。 include_top=False 表示不加载模型的顶层分类器，因为我们需要根据新的任务自定义分类器。
• base_model.trainable = False 冻结基础模型的权重，在训练过程中只训练新添加的分类器。
• layers.GlobalAveragePooling2D() 全局平均池化层，将特征图转换为固定长度的向量。
• layers.Dense(128, activation='relu') 和 layers.Dense(num_classes, activation='softmax') 自定义的分类器。

4. 学习率调度器

学习率 (Learning Rate) 是模型训练过程中一个非常重要的超参数。合适的学习率可以加速模型收敛，提高模型性能。学习率调度器 (Learning Rate Scheduler) 可以根据训练过程动态调整学习率。

def scheduler(epoch, lr):
    if epoch < 10:
        return lr # 前 10 个 epoch 学习率不变
    else:
        return lr * tf.math.exp(-0.1) # 之后每个 epoch 学习率衰减

callback = keras.callbacks.LearningRateScheduler(scheduler) # 创建学习率调度器回调函数

# 在模型训练时使用回调函数
history = model.fit(
    x_train, y_train,
    epochs=epochs,
    callbacks=[callback] # 添加学习率调度器回调函数
)

代码解释:

• scheduler(epoch, lr) 定义学习率调度函数，根据 epoch 数返回不同的学习率。
• keras.callbacks.LearningRateScheduler(scheduler) 创建学习率调度器回调函数，将自定义的 scheduler 函数传递给它。
• 在 model.fit() 中添加 callbacks=[callback]，即可在训练过程中使用学习率调度器。

总结与展望

恭喜你！通过本文的引导，你已经成功入门深度学习，并使用 TensorFlow/Keras 构建了你的第一个深度学习模型。从环境搭建、基础概念，到模型构建、训练评估，再到实战案例和进阶技巧，我们一步一个脚印，深入浅出地探索了深度学习的奥秘。

深度学习的世界广阔而精彩，TensorFlow/Keras 只是一个起点。未来，你可以继续探索更复杂的模型结构，尝试解决更具挑战性的问题。AI 的浪潮滚滚向前，掌握深度学习技术，你将拥有无限可能！

希望这篇文章能够帮助你迈出深度学习的第一步。如果你在学习过程中遇到任何问题，欢迎留言交流。让我们一起在 AI 的道路上不断前行！

---