【深度学习】—— 深入 Keras：从基础到实战的深度学习指南第1~4章共12章

《深入 Keras：从基础到实战的学习>深度学习指南》

文章目录

《深入 Keras：从基础到实战的学习>深度学习指南》
第1章：Keras简介
- 1.1 Keras的诞生与发展
- - 1.1.1 Keras出现的背景与学习>深度学习发展需求
  - 1.1.2 版本迭代历程与重大更新
- 1.2 Keras的设计理念与特点
- - 1.2.1 极简主义设计哲学与用户友好性
  - 1.2.2 高度模块化的架构优势
  - 1.2.3 快速实验能力的体现与意义
- 1.3 Keras在学习>深度学习框架中的地位
- - 1.3.1 与主流学习>深度学习框架（TensorFlow、PyTorch等）对比
  - 1.3.2 Keras的适用场景与独特价值
第2章：环境搭建
- 2.1 硬件与操作系统准备
- - 2.1.1 适合学习>深度学习的硬件配置建议（CPU、GPU等）
  - - CPU
    - GPU
    - 其他硬件
  - 2.1.2 不同操作系统（Windows、Linux、macOS）的适配要点
  - - Windows
    - Linux
    - macOS
- 2.2 Python环境安装与管理
- - 2.2.1 Python安装步骤与版本选择
  - 2.2.2 使用虚拟环境（如venv、conda）管理Python环境
  - - venv
    - conda
- 2.3 安装Keras及相关依赖
- - 2.3.1 安装Keras的多种方式（pip、conda等）
  - - 使用pip安装
    - 使用conda安装
  - 2.3.2 安装TensorFlow或其他后端引擎
  - 2.3.3 安装必要的依赖库（如NumPy、SciPy等）
- 2.4 验证安装与配置
- - 2.4.1 编写简单代码验证Keras是否安装成功
  - 2.4.2 解决安装过程中常见问题的方法
  - - 网络问题
    - 版本不兼容问题
    - GPU相关问题
第3章：Keras基础概念
- 3.1 张量（Tensor）
- - 3.1.1 张量的定义与基本概念
  - 3.1.2 张量在学习>深度学习中的作用
  - 3.1.3 Keras中张量的表示与操作
- 3.2 层（Layer）
- - 3.2.1 层的定义与分类
  - 3.2.2 常见层类型介绍
  - - 全连接层（Dense）
    - 卷积层（Convolutional Layers）
    - 循环层（Recurrent Layers）
  - 3.2.3 自定义层的方法与示例
- 3.3 模型（Model）
- - 3.3.1 模型的概念与组成
  - 3.3.2 序贯模型（Sequential）与函数式模型（Functional）的区别与使用场景
  - - 序贯模型（Sequential）
    - 函数式模型（Functional）
  - 3.3.3 模型的构建、编译与训练流程
- 3.4 损失函数（Loss Function）
- - 3.4.1 损失函数的作用与意义
  - 3.4.2 常见损失函数（均方误差、交叉熵等）的原理与应用
  - - 均方误差（Mean Squared Error，MSE）
    - 交叉熵（Cross Entropy）
- 3.4.3 自定义损失函数的方法
- 3.5 优化器（Optimizer）
- - 3.5.1 优化器的作用与原理
  - 3.5.2 常见优化器（SGD、Adagrad、Adadelta、Adam等）介绍
  - 3.5.3 如何选择合适的优化器
- 3.6 评估指标（Metrics）
- - 3.6.1 评估指标的重要性
  - 3.6.2 常见评估指标（准确率、召回率、F1 值、均方根误差等）介绍
  - 3.6.3 根据任务选择合适的评估指标
第 4 章：序贯模型（Sequential）
- 4.1 序贯模型的创建与结构
- - 4.1.1 序贯模型的定义与特点
  - 4.1.2 使用 Sequential 类创建模型的方法
  - 4.1.3 向模型中添加层的操作
- 4.2 模型编译
- - 4.2.1 编译模型的目的与参数设置
  - 4.2.2 选择损失函数、优化器和评估指标
- 4.3 模型训练
- - 4.3.1 训练模型的方法与参数（如 epochs、batch_size 等）
  - 4.3.2 使用训练数据和验证数据进行训练
  - 4.3.3 训练过程中的回调函数（Callback）应用
- 4.4 模型评估与预测
- - 4.4.1 使用测试数据评估模型性能
  - 4.4.2 模型预测的方法与应用
- 4.5 案例：使用序贯模型进行 MNIST 手写数字识别
- - 4.5.1 数据集介绍与加载
  - 4.5.2 数据预处理步骤
  - 4.5.3 构建、训练与评估模型的完整代码实现

第1章：Keras简介

1.1 Keras的诞生与发展

1.1.1 Keras出现的背景与学习>深度学习发展需求

在学习>深度学习的早期发展阶段，研究人员和开发者面临着一个复杂的局面。学习>深度学习算法虽然展现出了强大的潜力，例如在图像识别、语音识别等领域有了初步的成功案例，但实现这些算法的过程却充满挑战。当时，不同的学习>深度学习框架各自有着独特的语法和架构，开发和实验的成本较高。

传统的机器学习方法在处理复杂的非线性问题时，往往表现出局限性。随着数据量的爆炸式增长以及计算能力的提升，学习>深度学习模型，如卷积神经网络（CNN）和循环神经网络（RNN），逐渐成为解决复杂问题的有力工具。然而，这些模型的实现需要对底层的数学原理和编程有深入的理解，这使得许多初学者和快速迭代的开发者望而却步。

Keras就是在这样的背景下应运而生。它的目标是让学习>深度学习的开发变得更加简单、快速和直观。通过提供高层的API，Keras使得开发者可以专注于模型的设计和实验，而不必过多地关注底层的实现细节。

1.1.2 版本迭代历程与重大更新

Keras最初由François Chollet于2015年发布。从那时起，它经历了多个版本的迭代，不断地完善和扩展功能。

早期版本的Keras主要集中在提供一个简单易用的学习>深度学习框架，支持常见的模型架构，如序贯模型和函数式模型。这些版本使得开发者可以快速地构建和训练基本的学习>深度学习模型。

随着学习>深度学习技术的不断发展，Keras也进行了一系列的重大更新。例如，在与TensorFlow的集成方面，Keras逐渐成为TensorFlow的高级API，这使得Keras可以充分利用TensorFlow的强大计算能力和分布式训练功能。同时，Keras也增加了对更多层类型和损失函数的支持，进一步扩展了其应用范围。

在后续的版本中，Keras还引入了一些新的特性，如自定义层和模型的能力，以及对分布式训练和多GPU训练的更好支持。这些更新使得Keras不仅适用于初学者进行快速实验，也能够满足专业开发者在大规模项目中的需求。

1.2 Keras的设计理念与特点

1.2.1 极简主义设计哲学与用户友好性

Keras的设计哲学可以概括为极简主义。它的核心目标是让学习>深度学习的开发过程尽可能地简单和直观。Keras通过提供简洁的API，使得开发者可以用最少的代码来构建和训练复杂的学习>深度学习模型。

例如，使用Keras构建一个简单的全连接神经网络只需要几行代码：

from keras.models import Sequential
from keras.layers import Dense# 创建一个序贯模型
model = Sequential()
# 添加一个全连接层
model.add(Dense(units=64, activation='relu', input_dim=100))
# 添加输出层
model.add(Dense(units=10, activation='softmax'))

这种简洁的代码结构使得初学者可以快速上手，并且能够专注于模型的设计和实验。同时，Keras还提供了详细的文档和示例，进一步提高了用户的使用体验。

1.2.2 高度模块化的架构优势

Keras采用了高度模块化的架构，这意味着它的各个组件，如层、模型、损失函数和优化器等，都是独立的模块，可以方便地进行组合和替换。

这种模块化的架构使得开发者可以根据自己的需求灵活地构建模型。例如，在构建一个卷积神经网络时，开发者可以选择不同类型的卷积层、池化层和激活层，并将它们组合在一起。同时，如果需要更换优化器或损失函数，只需要修改相应的代码即可，而不需要对整个模型进行大规模的修改。

此外，模块化的架构也使得Keras的扩展性非常好。开发者可以很容易地自定义层、损失函数和优化器，以满足特定的需求。

1.2.3 快速实验能力的体现与意义

在学习>深度学习的研究和开发过程中，快速实验是非常重要的。Keras的设计使得开发者可以快速地构建和训练不同的模型，从而加速实验的过程。

Keras的高层API可以帮助开发者在短时间内完成模型的搭建，而不需要花费大量的时间来实现底层的算法。同时，Keras还支持多种后端引擎，如TensorFlow、Theano和CNTK等，开发者可以根据自己的需求选择合适的后端。

快速实验能力使得开发者可以更快地验证自己的想法，尝试不同的模型架构和参数设置，从而找到最优的解决方案。这对于学习>深度学习的研究和应用都具有重要的意义。

1.3 Keras在学习>深度学习框架中的地位

1.3.1 与主流学习>深度学习框架（TensorFlow、PyTorch等）对比

Keras与其他主流学习>深度学习框架，如TensorFlow和PyTorch，有着不同的特点和优势。

与TensorFlow相比，Keras是一个高级API，它提供了更简单、更直观的接口，使得开发者可以快速地构建和训练模型。而TensorFlow则是一个底层的学习>深度学习框架，它提供了更多的底层控制和灵活性，适合于需要深入定制和优化的项目。例如，在进行大规模的分布式训练时，TensorFlow的底层功能可以更好地满足需求。

与PyTorch相比，Keras的代码更加简洁，适合初学者和快速迭代的开发。PyTorch则以其动态图的特性而闻名，它在研究和实验方面具有一定的优势，特别是在需要频繁修改模型结构的情况。

1.3.2 Keras的适用场景与独特价值

Keras适用于多种场景，特别是以下几种情况：

快速原型开发：当需要快速验证一个想法或构建一个初步的模型时，Keras的简洁API可以帮助开发者在短时间内完成任务。
教育和学习：由于Keras的用户友好性，它非常适合作为学习>深度学习的教学工具，帮助初学者理解学习>深度学习的基本概念和模型架构。
小型项目和实验：对于一些小型的学习>深度学习项目或实验，Keras可以提供足够的功能，并且可以减少开发时间和成本。

Keras的独特价值在于它提供了一个简单、高效的学习>深度学习开发平台，使得更多的人可以参与到学习>深度学习的研究和应用中来。它的出现降低了学习>深度学习的门槛，促进了学习>深度学习技术的普及和发展。

第2章：环境搭建

2.1 硬件与操作系统准备

2.1.1 适合学习>深度学习的硬件配置建议（CPU、GPU等）

CPU

推荐选择具有较高核心数和时钟频率的CPU，例如英特尔的酷睿i7或i9系列，或者AMD的锐龙系列。这些CPU通常具有6 - 16个核心，能够并行处理多个任务，提高数据处理效率。同时，较高的时钟频率可以加快单个线程的计算速度。

GPU

推荐使用NVIDIA的高端GPU，如RTX 30系列（如RTX 3080、RTX 3090）或A100等。这些GPU具有较高的计算能力和显存容量，可以处理大规模的数据集和复杂的模型。例如，RTX 3090拥有10496个CUDA核心和24GB的GDDR6X显存，能够在短时间内完成大量的矩阵运算。

其他硬件

除了CPU和GPU，还需要考虑内存和存储设备。学习>深度学习模型通常需要大量的内存来存储数据和模型参数，建议至少配备16GB以上的内存，如果进行大规模的训练，32GB或64GB的内存会更加合适。

在存储方面，使用固态硬盘（SSD）可以显著提高数据读取和写入的速度，减少数据加载时间。对于大规模的数据集，建议使用大容量的SSD或企业级的存储设备。

2.1.2 不同操作系统（Windows、Linux、macOS）的适配要点

Windows

Windows是最常见的桌面操作系统，具有简单易用的特点。在Windows上安装学习>深度学习环境相对简单，许多学习>深度学习框架都提供了Windows版本的安装包。

然而，Windows在某些学习>深度学习框架的性能优化方面可能不如Linux。在使用GPU进行学习>深度学习训练时，需要安装NVIDIA的显卡驱动和CUDA工具包，并且确保它们与学习>深度学习框架的版本兼容。

Linux

Linux是学习>深度学习领域最常用的操作系统，因为它具有高度的可定制性和性能优化能力。许多学习>深度学习框架在Linux上的性能表现更好，并且可以方便地进行分布式训练。

常见的Linux发行版如Ubuntu、CentOS等都可以用于学习>深度学习开发。在Linux上安装学习>深度学习环境需要一些基本的命令行操作知识，例如使用包管理器（如apt、yum）来安装软件包。同时，需要正确配置CUDA和cuDNN以支持GPU加速。

macOS

macOS是苹果公司的操作系统，具有简洁美观的界面和良好的用户体验。然而，由于macOS不支持NVIDIA的CUDA平台，因此在使用GPU进行学习>深度学习训练时受到一定的限制。

在macOS上，可以使用CPU进行学习>深度学习开发，或者使用苹果的Metal框架来加速某些学习>深度学习任务。一些学习>深度学习框架如TensorFlow也提供了对macOS的支持，但在性能上可能不如使用NVIDIA GPU的系统。

2.2 Python环境安装与管理

2.2.1 Python安装步骤与版本选择

Python是学习>深度学习开发中最常用的编程语言，许多学习>深度学习框架都是基于Python开发的。在安装Python时，需要选择合适的版本。

目前，Python 3.7 - 3.10是比较推荐的版本，因为大多数学习>深度学习框架都对这些版本提供了良好的支持。可以从Python官方网站（https://www.python.org/downloads/）下载适合自己操作系统的Python安装包。

在安装过程中，需要注意勾选“Add Python to PATH”选项，这样可以在命令行中直接使用Python命令。安装完成后，可以在命令行中输入以下命令来验证Python是否安装成功：

python --version

2.2.2 使用虚拟环境（如venv、conda）管理Python环境

在进行学习>深度学习开发时，不同的项目可能需要不同版本的Python和依赖库。为了避免不同项目之间的依赖冲突，建议使用虚拟环境来管理Python环境。

venv

venv是Python标准库中的一个模块，用于创建轻量级的虚拟环境。可以使用以下命令创建一个新的虚拟环境：

python -m venv myenv

其中，myenv是虚拟环境的名称。激活虚拟环境的命令如下：

在Windows上：

myenv\Scripts\activate

在Linux和macOS上：

source myenv/bin/activate

激活虚拟环境后，安装的所有Python包都将只在该虚拟环境中可用。退出虚拟环境的命令是：

deactivate

conda

conda是一个功能强大的包管理和环境管理工具，常用于数据科学和学习>深度学习领域。可以从Anaconda官方网站（https://www.anaconda.com/products/individual）下载并安装Anaconda或Miniconda。

使用conda创建新的虚拟环境的命令如下：

conda create -n myenv python=3.8

其中，myenv是虚拟环境的名称，python=3.8指定了Python的版本。激活虚拟环境的命令是：

conda activate myenv

退出虚拟环境的命令是：

conda deactivate

2.3 安装Keras及相关依赖

2.3.1 安装Keras的多种方式（pip、conda等）

Keras可以通过多种方式进行安装，最常用的方式是使用pip和conda。

使用pip安装

pip是Python的包管理工具，可以使用以下命令来安装Keras：

pip install keras

如果需要指定Keras的版本，可以使用以下命令：

pip install keras==2.8.0

使用conda安装

如果使用conda管理Python环境，可以使用以下命令来安装Keras：

conda install keras

conda会自动处理Keras的依赖关系，并确保安装的版本与其他库兼容。

2.3.2 安装TensorFlow或其他后端引擎

Keras本身是一个高级的学习>深度学习API，需要依赖一个后端引擎来进行实际的计算。目前，Keras主要支持TensorFlow作为后端引擎。

可以使用以下命令来安装TensorFlow：

pip install tensorflow

如果需要使用GPU加速，需要安装支持GPU的TensorFlow版本，并确保已经安装了NVIDIA的显卡驱动、CUDA工具包和cuDNN库。

除了TensorFlow，Keras还曾经支持Theano和CNTK等后端引擎，但目前这些后端已经逐渐被弃用。

2.3.3 安装必要的依赖库（如NumPy、SciPy等）

Keras依赖于一些其他的Python库，如NumPy、SciPy等。这些库提供了基本的数值计算和科学计算功能。

可以使用以下命令来安装这些依赖库：

pip install numpy scipy

或者使用conda进行安装：

conda install numpy scipy

2.4 验证安装与配置

2.4.1 编写简单代码验证Keras是否安装成功

安装完成后，可以编写一个简单的Python代码来验证Keras是否安装成功。以下是一个简单的示例：

import keras
from keras.models import Sequential
from keras.layers import Dense# 创建一个序贯模型
model = Sequential()
# 添加一个全连接层
model.add(Dense(units=64, activation='relu', input_dim=100))
# 添加输出层
model.add(Dense(units=10, activation='softmax'))# 编译模型
model.compile(loss='categorical_crossentropy',optimizer='sgd',metrics=['accuracy'])print("Keras安装成功！")

运行上述代码，如果没有报错，则说明Keras安装成功。

2.4.2 解决安装过程中常见问题的方法

在安装Keras和相关依赖库的过程中，可能会遇到一些常见的问题，以下是一些解决方法：

网络问题

如果在使用pip或conda安装时遇到网络问题，可以尝试更换镜像源。例如，使用清华大学的镜像源：

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple keras

或者在conda中配置镜像源：

conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
conda config --set show_channel_urls yes

版本不兼容问题

如果遇到版本不兼容的问题，需要检查各个库的版本，并确保它们之间相互兼容。可以参考学习>深度学习框架的官方文档来选择合适的版本。

GPU相关问题

如果在使用GPU加速时遇到问题，需要检查NVIDIA的显卡驱动、CUDA工具包和cuDNN库的版本是否正确安装，并且与学习>深度学习框架的版本兼容。可以参考NVIDIA的官方文档来进行安装和配置。

第3章：Keras基础概念

3.1 张量（Tensor）

3.1.1 张量的定义与基本概念

在学习>深度学习的世界里，张量（Tensor）是最基础且核心的数据结构，可以把它看作是多维数组的一种泛化表示。从简单的标量到复杂的高维数组，张量涵盖了各种维度的数据形式。

标量（零维张量）：最简单的张量形式，仅表示一个单一的数值，如整数或浮点数。例如，在计算图像的平均亮度时，得到的平均亮度值就是一个标量。用数学符号表示，一个标量 $s$ 可以写成 $s = 5$ 。
向量（一维张量）：由一组数值组成的序列，可看作是一排数字。在学习>深度学习中，向量常用于表示特征向量。比如，在文本分类任务中，一个词的词向量就可以用一维张量表示。若有一个向量 $\mathbf{v}$ ，其维度为 $n$ ，可以表示为 $\mathbf{v} = [v_1, v_2, \cdots, v_n]$ ，例如 $\mathbf{v} = [1, 3, 5, 7]$ 。
矩阵（二维张量）：由行和列组成的二维数组。在图像处理中，灰度图像就可以用二维张量来表示，其中每个元素代表图像中对应位置的像素值。一个 $\times n$ 的矩阵 $\mathbf{M}$ 可以表示为：
$
\mathbf{M} =
\begin{bmatrix}
m_{11} & m_{12} & \cdots & m_{1n} \
m_{21} & m_{22} & \cdots & m_{2n} \
\vdots & \vdots & \ddots & \vdots \
m_{m1} & m_{m2} & \cdots & m_{mn}
\end{bmatrix}
$
高维张量：用于表示更复杂的数据结构。在处理彩色图像时，由于彩色图像包含红、绿、蓝三个通道，因此需要使用三维张量来表示，其中两个维度表示图像的高度和宽度，第三个维度表示颜色通道。若有一个彩色图像的张量 $\mathbf{T}$ ，其形状为 $\times w \times 3$ （ $h$ 为高度， $w$ 为宽度）。当处理一批图像时，则需使用四维张量，额外的一维用于表示图像的数量，形状通常为 $\times h \times w \times 3$ （ $N$ 为图像数量）。

3.1.2 张量在学习>深度学习中的作用

在学习>深度学习中，张量贯穿了整个数据处理和模型训练的过程，扮演着至关重要的角色。

数据表示：所有的输入数据，无论是图像、文本还是音频，都会被转换为张量的形式，以便模型能够进行处理。例如，将一张 $28 \times 28$ 的灰度图像转换为形状为 $(28, 28)$ 的二维张量，或者将一批 $100$ 张这样的图像转换为形状为 $(100, 28, 28)$ 的三维张量。
模型参数存储：模型的参数，如神经网络中的权重和偏置，也是以张量的形式存储的。在一个简单的全连接层中，权重矩阵是一个二维张量，偏置向量是一个一维张量。这些参数在训练过程中会根据损失函数的反馈不断更新，以使得模型能够更好地拟合数据。
中间计算结果：在神经网络的前向传播过程中，每一层的输出都是一个张量，这些张量会作为下一层的输入，直到最终得到模型的输出。例如，在卷积层中，输入的图像张量经过卷积操作后会得到一个新的特征图张量，这个特征图张量又会作为下一层（如池化层）的输入。

3.1.3 Keras中张量的表示与操作

在Keras中，张量通常由后端引擎（如TensorFlow）来进行底层的表示和操作。Keras提供了一些高级的API来方便我们对张量进行操作。

我们可以使用Keras的 Input 层来定义输入张量。例如：

from keras.layers import Input# 定义一个输入张量，形状为 (None, 28, 28)，表示输入数据的维度为 28x28，None表示批量大小可以是任意值
input_tensor = Input(shape=(28, 28))

Keras还提供了一些函数来对张量进行基本的操作，如加法、乘法等。例如：

from keras.layers import Input, Add
import keras.backend as K# 定义两个输入张量
input1 = Input(shape=(10,))
input2 = Input(shape=(10,))# 对两个张量进行加法操作
output = Add()([input1, input2])

由于我没办法直接提供可访问的图片，你可以通过以下方式获取相关图片：

网络搜索：在百度图片、必应图片等搜索引擎中，输入“Keras 张量加法示意图”“Keras 全连接层示意图”等关键词，能找到大量相关的图片资源。
相关书籍和文档：查阅学习>深度学习相关的专业书籍，如《学习>深度学习》（花书）、《Python学习>深度学习》等，或者 Keras 的官方文档，里面有丰富的配图辅助理解。

3.2 层（Layer）

3.2.1 层的定义与分类

在Keras中，层（Layer）是构建神经网络的基本组件，它可以看作是一个数据处理单元，接收输入张量，经过一系列的计算后输出一个新的张量。

根据功能的不同，层可以分为多种类型，常见的层类型包括全连接层、卷积层、循环层等。

3.2.2 常见层类型介绍

全连接层（Dense）

全连接层是神经网络中最基本的层类型之一。在全连接层中，每个神经元都与上一层的所有神经元相连。这种连接方式使得全连接层能够学习到输入数据的全局特征。

在Keras中，可以使用 Dense 层来创建全连接层。例如：

from keras.layers import Dense# 创建一个全连接层，包含 64 个神经元，激活函数为 ReLU
dense_layer = Dense(units=64, activation='relu')

全连接层的计算过程可以用以下公式表示：$ \mathbf{y} = f(\mathbf{W} \cdot \mathbf{x} + \mathbf{b}) $，其中，$ \mathbf{x}$ 是输入向量， $\mathbf{W}$ 是权重矩阵， $\mathbf{b}$ 是偏置向量， $f$ 是激活函数。

你可以通过搜索“Keras 全连接层示意图”在网络上找到对应的图片。

卷积层（Convolutional Layers）

卷积层主要用于处理具有网格结构的数据，如图像、音频等。卷积层通过卷积核在输入数据上滑动，进行卷积操作，从而提取数据的局部特征。

Keras提供了多种卷积层，如 Conv1D、Conv2D 和 Conv3D，分别用于处理一维、二维和三维数据。例如：

from keras.layers import Conv2D# 创建一个二维卷积层，包含 32 个卷积核，卷积核大小为 3x3，激活函数为 ReLU
conv_layer = Conv2D(filters=32, kernel_size=(3, 3), activation='relu')

二维卷积操作的数学公式为：$ y_{ij} = \sum_{m=0}^{M - 1} \sum_{n=0}^{N - 1} x_{i + m, j + n} \cdot k_{mn} $，其中，$ x$ 是输入图像， $k$ 是卷积核， $y$ 是卷积后的输出。

你可以通过搜索“Keras 二维卷积操作示意图”在网络上找到对应的图片。

循环层（Recurrent Layers）

循环层主要用于处理序列数据，如文本、时间序列等。循环层通过在序列的每个时间步上共享参数，能够捕捉序列中的时间依赖关系。

常见的循环层包括简单循环层（SimpleRNN）、长短期记忆网络（LSTM）和门控循环单元（GRU）。例如：

from keras.layers import LSTM# 创建一个 LSTM 层，包含 128 个单元
lstm_layer = LSTM(units=128)

以简单循环层为例，其计算过程可以用以下公式表示： $h_t = \tanh(\mathbf{W}_{xh} \cdot x_t + \mathbf{W}_{hh} \cdot h_{t - 1} + \mathbf{b}_h)$ ，其中， $x_t$ 是当前时间步的输入， $h_{t - 1}$ 是上一个时间步的隐藏状态， $h_t$ 是当前时间步的隐藏状态， $\mathbf{W}_{xh}$ 、 $\mathbf{W}_{hh}$ 是权重矩阵， $\mathbf{b}_h$ 是偏置向量。

你可以通过搜索“Keras 简单循环层示意图”在网络上找到对应的图片。

3.2.3 自定义层的方法与示例

在某些情况下，我们可能需要自定义层来实现特定的功能。在Keras中，自定义层需要继承 keras.layers.Layer 类，并实现 __init__、build 和 call 方法。

以下是一个简单的自定义层示例，实现一个简单的线性变换层：

import keras
from keras.layers import Layerclass SimpleLinearLayer(Layer):def __init__(self, units=32, **kwargs):super(SimpleLinearLayer, self).__init__(**kwargs)self.units = unitsdef build(self, input_shape):# 创建可训练的权重和偏置self.w = self.add_weight(shape=(input_shape[-1], self.units),initializer='random_normal',trainable=True)self.b = self.add_weight(shape=(self.units,),initializer='random_normal',trainable=True)super(SimpleLinearLayer, self).build(input_shape)def call(self, inputs):# 定义前向传播过程return keras.backend.dot(inputs, self.w) + self.bdef get_config(self):config = super(SimpleLinearLayer, self).get_config()config.update({'units': self.units})return config

3.3 模型（Model）

3.3.1 模型的概念与组成

在Keras中，模型（Model）是由多个层组成的有向无环图（DAG），它定义了数据从输入到输出的流动过程。模型可以看作是一个完整的神经网络，它接收输入数据，经过一系列的层处理后输出预测结果。

模型通常由输入层、中间层（也称为隐藏层）和输出层组成。输入层负责接收原始数据，中间层用于提取数据的特征，输出层则根据提取的特征进行预测。

3.3.2 序贯模型（Sequential）与函数式模型（Functional）的区别与使用场景

序贯模型（Sequential）

序贯模型是Keras中最简单的模型类型，它是由一系列层按顺序堆叠而成的。序贯模型适用于构建简单的线性模型，即输入数据依次经过每个层进行处理。

以下是一个使用序贯模型构建简单全连接神经网络的示例：

from keras.models import Sequential
from keras.layers import Dense# 创建一个序贯模型
model = Sequential()
# 添加第一个全连接层
model.add(Dense(units=64, activation='relu', input_dim=100))
# 添加第二个全连接层
model.add(Dense(units=10, activation='softmax'))

序贯模型的结构简单直观，就像一条流水线，数据从一端流入，经过各个层的处理后从另一端流出。你可以通过搜索“Keras 序贯模型示意图”在网络上找到对应的图片。

函数式模型（Functional）

函数式模型则更加灵活，它允许我们构建复杂的模型结构，如多输入、多输出模型和共享层模型。函数式模型通过定义输入和输出张量之间的关系来构建模型。

以下是一个使用函数式模型构建简单卷积神经网络的示例：

from keras.layers import Input, Conv2D, MaxPooling2D, Flatten, Dense
from keras.models import Model# 定义输入张量
input_tensor = Input(shape=(28, 28, 1))# 构建卷积层和池化层
x = Conv2D(filters=32, kernel_size=(3, 3), activation='relu')(input_tensor)
x = MaxPooling2D(pool_size=(2, 2))(x)
x = Flatten()(x)# 构建全连接层
output_tensor = Dense(units=10, activation='softmax')(x)# 创建模型
model = Model(inputs=input_tensor, outputs=output_tensor)

函数式模型可以处理更复杂的网络结构，其数据流动可以是多分支、多输入多输出的。你可以通过搜索“Keras 函数式模型示意图”在网络上找到对应的图片。

3.3.3 模型的构建、编译与训练流程

在Keras中，构建模型的过程就是将各个层组合在一起的过程。构建好模型后，需要对模型进行编译，指定损失函数、优化器和评估指标。

以下是一个完整的模型构建、编译与训练的示例：

from keras.models import Sequential
from keras.layers import Dense
import numpy as np# 构建模型
model = Sequential()
model.add(Dense(units=64, activation='relu', input_dim=100))
model.add(Dense(units=10, activation='softmax'))# 编译模型
model.compile(loss='categorical_crossentropy',optimizer='adam',metrics=['accuracy'])# 生成随机数据
x_train = np.random.random((1000, 100))
y_train = np.random.randint(10, size=(1000,))
y_train = np.eye(10)[y_train]# 训练模型
model.fit(x_train, y_train, epochs=10, batch_size=32)

模型的编译过程是为模型配置训练所需的参数，损失函数用于衡量模型预测结果与真实标签之间的差异，优化器用于更新模型的参数以最小化损失函数，评估指标用于评估模型的性能。训练过程则是通过不断地将输入数据输入到模型中，根据损失函数的反馈更新模型参数，直到模型达到满意的性能。

3.4 损失函数（Loss Function）

3.4.1 损失函数的作用与意义

在学习>深度学习中，损失函数（Loss Function）也被称为目标函数或代价函数，它的主要作用是衡量模型预测结果与真实标签之间的差异。损失函数是模型训练的核心，它为模型的参数更新提供了方向。

在训练过程中，我们的目标是通过调整模型的参数，使得损失函数的值尽可能地小。损失函数的值越小，说明模型的预测结果与真实标签越接近，模型的性能也就越好。

3.4.2 常见损失函数（均方误差、交叉熵等）的原理与应用

均方误差（Mean Squared Error，MSE）

均方误差是一种常见的损失函数，主要用于回归问题。它的计算方法是计算预测值与真实值之间差值的平方的平均值。

均方误差的数学公式为： $\frac{1}{n} \sum_{i = 1}^{n} (y_i - \hat{y}_i)^2$ ，其中， $n$ 是样本数量， $y_i$ 是真实值， $\hat{y}_i$ 是预测值。

均方误差的优点是计算简单，并且对异常值比较敏感。在预测房价、股票价格等连续数值的问题中，均方误差是一个常用的损失函数。

交叉熵（Cross Entropy）

交叉熵主要用于分类问题，特别是多分类问题。交叉熵衡量的是两个概率分布之间的差异。

在二分类问题中，交叉熵的公式为： $\frac{1}{n} \sum_{i = 1}^{n} [y_i \log(\hat{y}_i) + (1 - y_i) \log(1 - \hat{y}_i)]$ ，其中， $y_i$ 是真实标签（取值为 0 或 1）， $\hat{y}_i$ 是预测的概率。

在多分类问题中，交叉熵的公式为： $\frac{1}{n} \sum_{i = 1}^{n} \sum_{j = 1}^{k} y_{ij} \log(\hat{y}_{ij})$ ，其中， $k$ 是类别数量， $y_{ij}$ 是第 $i$ 个样本属于第 $j$ 类的真实标签（通常是一个 one - hot 编码向量）， $\hat{y}_{ij}$ 是第 $i$ 个样本属于第 $j$ 类的预测概率。

交叉熵的优点是能够有效地衡量分类问题中模型的性能，并且在训练过程中能够引导模型朝着正确的方向进行参数更新。

3.4.3 自定义损失函数的方法

在某些情况下，常规的损失函数无法完全满足模型训练的特定需求，这时就需要自定义损失函数。以一个实际场景为例，假设我们正在处理一个医疗影像诊断任务，模型不仅要准确判断影像中的病灶类别（分类任务），还要尽可能精确地预测病灶的大小（回归任务），这就要求损失函数能够综合考量这两个方面。

在Keras中，自定义损失函数相对灵活。首先需要导入 keras.backend 模块，它提供了一系列用于构建和操作张量的函数，是自定义损失函数的基础。例如：

import keras.backend as K

接着，就可以开始定义自己的损失函数。假设我们希望结合分类任务的交叉熵损失和回归任务的均方误差损失，且给分类损失分配一个权重 alpha，给回归损失分配权重 (1 - alpha)，可以这样写：

def custom_loss(alpha):def loss(y_true, y_pred):# 假设 y_pred 的前一部分是分类预测结果，后一部分是回归预测结果y_pred_class = y_pred[:, :num_classes] y_pred_reg = y_pred[:, num_classes:] y_true_class = y_true[:, :num_classes] y_true_reg = y_true[:, num_classes:] # 计算分类交叉熵损失ce_loss = -K.mean(K.sum(y_true_class * K.log(y_pred_class + K.epsilon()), axis=-1))# 计算回归均方误差损失mse_loss = K.mean(K.square(y_true_reg - y_pred_reg))return alpha * ce_loss + (1 - alpha) * mse_lossreturn loss# 实例化自定义损失函数，假设分类损失权重为 0.7
my_loss = custom_loss(0.7)

这里引入了一个小的常量 K.epsilon()，它用于避免对数运算中出现 log(0) 的情况，确保计算的稳定性。

定义好自定义损失函数后，在模型编译阶段就可以像使用内置损失函数一样使用它：

model.compile(loss=my_loss,optimizer='adam',metrics=['accuracy'])

3.5 优化器（Optimizer）

3.5.1 优化器的作用与原理

优化器在学习>深度学习模型训练中扮演着“领航员”的角色，其核心作用是依据损失函数反馈的信息，对模型的参数进行调整，以逐步降低损失值，让模型的预测结果尽可能地接近真实标签。

从原理上讲，它基于某种优化算法，在每次迭代训练过程中，计算损失函数关于模型参数的梯度，然后根据梯度的方向和大小来更新参数。可以把模型的训练想象成在一个复杂的高维地形中寻找最低点（对应损失函数的最小值），优化器就是那个指引方向、控制步伐大小的导航工具。

以常见的随机梯度下降（SGD）优化器为例，在每次迭代时，它从训练数据集中随机抽取一个小批量（mini-batch）的数据样本，计算这批样本上损失函数关于模型参数的梯度，然后按照下面这个简单却核心的公式更新参数：
$\theta_{new} = \theta_{old} - \eta \cdot \nabla_{\theta} L(\theta_{old})$
其中， ${\theta}$ 表示模型参数， $\theta_{new}$ 是更新后的参数， $\theta_{old}$ 是当前参数， $\eta$ 是学习率（learning rate），它控制着每次参数更新的步长， $\nabla_{\theta} L(\theta_{old})$ 是损失函数 $L$ 在当前参数 $\theta_{old}$ 处的梯度。

3.5.2 常见优化器（SGD、Adagrad、Adadelta、Adam等）介绍

随机梯度下降（SGD）：这是最基础的优化器，如前文所述，它以随机抽取小批量数据计算梯度的方式，朝着损失函数减小的方向更新参数。优点是简单直观、计算成本相对较低；缺点是学习率固定，在训练过程中可能会因为学习率过大跳过最优解，或者因为学习率过小导致收敛速度过慢。
Adagrad：Adagrad优化器在 SGD 的基础上进行了改进，它能够自适应地调整每个参数的学习率。对于出现频率较低的参数，给予较大的学习率，使其能够更快地收敛；对于频繁出现的参数，降低学习率，避免更新过度。其计算公式如下：
$\theta_{t + 1, i} = \theta_{t, i} - \frac{\eta}{\sqrt{G_{t, i} + \epsilon}} \cdot \nabla_{\theta_{t, i}} L(\theta_{t})$
其中， $\theta_{t + 1, i}$ 和 $\theta_{t, i}$ 分别是参数 $\theta_{i}$ 在 $t + 1$ 次和 $t$ 次迭代时的值， $G_{t, i}$ 是从初始到 $t$ 次迭代关于参数 $\theta_{i}$ 的梯度平方累积和， $\epsilon$ 是一个极小的常数，用于防止分母为零， $\eta$ 是初始学习率。不过，Adagrad 的一个问题是随着训练的进行，学习率会不断减小，可能导致在训练后期收敛过慢甚至停止。
Adadelta：Adadelta 优化器进一步改进了 Adagrad 的不足，它同样是自适应调整学习率，但不再依赖于全局的初始学习率。它通过引入一个衰减因子 $\rho$ ，只累积过去一段时间内的梯度平方，而不是从初始就全部累积，并且采用一种近似的牛顿法来计算更新步长，使得在训练后期也能保持较为稳定的学习率。公式如下：
$\Delta \theta_{t} = - \frac{\sqrt{E[g^2]_{t - 1} + \epsilon}}{\sqrt{G_{t} + \epsilon}} \cdot g_{t}$
其中， $\Delta \theta_{t}$ 是参数在 $t$ 次迭代时的更新量， $g_{t}$ 是当前梯度， $E[g^2]_{t - 1}$ 是过去一段时间内梯度平方的指数加权移动平均值， $G_{t}$ 是过去一段时间内梯度平方的累积和， $\epsilon$ 是防止分母为零的常数。
Adam：Adam 优化器结合了 Adagrad 和 RMSProp（一种类似 Adadelta 的优化器）的优点，它同时对梯度的一阶矩（均值）和二阶矩（方差）进行估计，并且通过引入偏置校正机制，使得在训练初期也能得到较为准确的估计值。计算公式如下：
$m_{t} = \beta_{1} \cdot m_{t - 1} + (1 - \beta_{1}) \cdot g_{t}$
$v_{t} = \beta_{2} \cdot v_{t - 1} + (1 - \beta_{2}) \cdot g_{t}^2$
$\hat{m}_{t} = \frac{m_{t}}{1 - \beta_{1}^t}$
$\hat{v}_{t} = \frac{v_{t}}{1 - \beta_{2}^t}$
$\theta_{t + 1} = \theta_{t} - \frac{\eta}{\sqrt{\hat{v}_{t} + \epsilon}} \cdot \hat{m}_{t}$
其中， $m_{t}$ 是梯度的一阶矩估计， $v_{t}$ 是梯度的二阶矩估计， $\beta_{1}$ 和 $\beta_{2}$ 是衰减因子，通常取值接近 1， $\hat{m}_{t}$ 和 $\hat{v}_{t}$ 是经过偏置校正后的一阶矩和二阶矩估计， $\eta$ 是学习率， $\theta_{t + 1}$ 和 $\theta_{t}$ 是更新前后的参数。Adam 优化器在实际应用中表现出了良好的性能，收敛速度较快且相对稳定，是目前使用非常广泛的优化器。

3.5.3 如何选择合适的优化器

选择合适的优化器需要综合考虑多个因素，包括模型的复杂度、数据集的大小和特征、训练时间要求等。

对于简单的模型和小规模数据集，SGD 可能就足够满足需求，因为它简单易懂，计算开销小，在这种情况下能够较快地找到一个较优解。

如果模型较为复杂，参数众多，或者数据集较大且具有不同的特征分布，自适应优化器如 Adam、Adagrad、Adadelta 等往往更具优势。它们能够根据参数的不同特性自动调整学习率，避免在复杂的参数空间中陷入局部最优解。

当训练时间有限时，Adam 通常是一个不错的选择，它的收敛速度相对较快，能在较短时间内使模型达到一个较好的性能状态。不过，在一些特定的研究领域，如对模型的收敛过程有深入研究需求，或者模型具有特殊的结构和数据特点时，可能需要对不同优化器进行细致的实验对比，通过观察损失函数的变化曲线、模型的准确率等指标来确定最适合的优化器。

3.6 评估指标（Metrics）

3.6.1 评估指标的重要性

评估指标是衡量模型性能优劣的“标尺”，在学习>深度学习模型的开发过程中起着至关重要的作用。它不仅能够直观地反映模型在训练集和测试集上的表现，帮助我们判断模型是否达到了预期的学习效果，还为模型的改进和优化提供了方向。

在实际应用中，不同的任务有不同的目标，例如在图像分类任务中，我们希望模型能够准确地识别出图像所属的类别；在回归任务中，我们则期望模型预测的数值与真实数值尽可能接近。评估指标将这些抽象的目标量化，使得我们能够通过具体的数值来比较不同模型的好坏，或者同一模型在不同训练阶段的进步情况。

3.6.2 常见评估指标（准确率、召回率、F1 值、均方根误差等）介绍

准确率（Accuracy）：这是分类任务中最常用的评估指标之一，它的计算公式为：
$\frac{TP + TN}{TP + TN + FP + FN}$
其中， $TP$ （True Positive）表示真正例，即模型预测为正例且实际为正例的样本数； $TN$ （True Negative）表示真负例，即模型预测为负例且实际为负例的样本数； $FP$ （False Positive）表示假正例，即模型预测为正例但实际为负例的样本数； $FN$ （False Negative）表示假负例，即模型预测为负例但实际为正例的样本数。准确率反映了模型预测正确的样本占总样本数的比例，直观易懂，但在某些类别不平衡的数据集上可能会产生误导，比如当正例样本极少时，即使模型总是预测为负例，准确率也可能很高。
召回率（Recall）：召回率在信息检索和分类任务中也非常重要，尤其关注正例样本的识别情况，计算公式为：
$\frac{TP}{TP + FN}$
它表示实际的正例样本中被模型正确预测为正例的比例，反映了模型对正例的覆盖程度。在一些对正例敏感的应用场景，如疾病诊断（希望尽可能找出所有患病的人），召回率是一个关键指标。
F1 值（F1 Score）：由于准确率和召回率在某些情况下可能存在矛盾，F1 值应运而生，它是准确率和召回率的调和平均数，计算公式为：
$\frac{2 \times Precision \times Recall}{Precision + Recall}$
其中， $\frac{TP}{TP + FP}$ ，即精确率，表示预测为正例的样本中真正例的比例。F1 值综合考虑了准确率和召回率，能够更全面地衡量模型在分类任务中的性能，取值范围在 0 到 1 之间，越接近 1 表示模型性能越好。
均方根误差（Root Mean Squared Error，RMSE）：这是回归任务中常用的评估指标，它衡量的是模型预测值与真实值之间的平均偏离程度，计算公式为：
$\sqrt{\frac{1}{n} \sum_{i = 1}^{n}(y_i - \hat{y}_i)^2}$
其中， $n$ 是样本数量， $y_i$ 是真实值， $\hat{y}_i$ 是预测值。RMSE 的值越小，说明模型的预测值与真实值越接近，在预测房价、股票价格等连续数值的问题中广泛应用。

3.6.3 根据任务选择合适的评估指标

在选择评估指标时，首先要明确任务的类型。对于分类任务，如文本分类、图像分类等，如果数据集相对平衡，准确率是一个基本的衡量指标，但为了更全面地评估，通常还需要结合召回率和 F1 值，尤其是在涉及到多类别且类别重要性不同的情况下，F1 值能够更好地反映模型的综合性能。如果是医疗诊断、故障检测等对漏检（假负例）极为敏感的分类任务，召回率则更为关键，需要确保模型尽可能多地检测出阳性样本。

对于回归任务，如预测气温、销售额等，均方根误差是最常用的指标之一，它直观地反映了预测值与真实值的偏差程度。若要进一步考察模型预测的稳定性，还可以结合平均绝对误差（MAE）等指标，MAE 的计算公式为 $\frac{1}{n} \sum_{i = 1}^{n} \vert y_i - \hat{y}_i \vert$ ，它与 RMSE 的区别在于对误差的处理方式不同，MAE 对离群值相对不敏感，能从另一个角度反映模型的性能。

此外，在一些复杂的实际应用中，可能需要综合使用多种评估指标。比如在自动驾驶领域，不仅要考虑模型对道路、车辆等目标的识别准确率，还要关注预测的位置、速度等信息的均方根误差，以确保自动驾驶系统的安全性和可靠性。

综上所述，了解各种评估指标的含义、特点以及适用场景，根据具体任务合理选择和组合评估指标，是学习>深度学习模型开发过程中的一个重要环节，能够帮助我们更准确地评估模型性能，推动模型的不断优化。

第 4 章：序贯模型（Sequential）

4.1 序贯模型的创建与结构

4.1.1 序贯模型的定义与特点

序贯模型是 Keras 中一种简单且直观的构建神经网络模型的方式，它就如同一条井然有序的流水线。其核心特点在于模型中的各层按照顺序依次堆叠，数据从输入层进入后，逐次流经每一个中间层，最终从输出层得到预测结果。这种线性的结构使得模型的构建过程清晰易懂，尤其适合初学者快速上手搭建简单的神经网络架构，能够高效处理如全连接神经网络等具有线性结构的数据处理流程。

4.1.2 使用 Sequential 类创建模型的方法

在 Keras 中，利用 Sequential 类创建序贯模型轻而易举。首先需要导入相关模块：

from keras.models import Sequential

随后，通过实例化 Sequential 类便可得到一个空的序贯模型框架，为后续添加层做准备：

model = Sequential()

4.1.3 向模型中添加层的操作

一旦创建了序贯模型实例，就可以向其中添加各种层。以构建一个简单的多层感知机（MLP）用于分类任务为例，若输入数据特征维度为 784（如将 28×28 的图像展平后的维度），首先添加一个具有 128 个神经元、激活函数为 relu 的全连接层：

from keras.layers import Densemodel.add(Dense(units=128, activation='relu', input_dim=784))

这里的 input_dim 参数指定了输入数据的维度，仅在首层需要设置。接着，可以继续添加更多层，如再添加一个包含 10 个神经元、激活函数为 softmax 用于多分类的输出层：

model.add(Dense(units=10, activation='softmax'))

如此这般，通过多次调用 add 方法，就能按照需求搭建起一个完整的序贯模型结构。

4.2 模型编译

4.2.1 编译模型的目的与参数设置

编译模型是模型训练前至关重要的一步，其目的在于为训练过程配置必要的参数，使得模型能够依据这些设定高效地学习。

4.2.2 选择损失函数、优化器和评估指标

损失函数：如前所述，损失函数衡量模型预测结果与真实标签之间的差异，是模型训练的“导航仪”。对于多分类任务，常用的损失函数是 categorical_crossentropy，假设模型输出的预测概率分布为 $\hat{y}$ ，真实标签的 one - hot 编码为 $y$ ，其计算公式（以样本维度求和平均形式呈现）为：
$\frac{1}{n} \sum_{i = 1}^{n} \sum_{j = 1}^{k} y_{ij} \log(\hat{y}_{ij})$ ，其中 $n$ 为样本数量， $k$ 为类别数量。对于回归任务，可能会选用均方误差（mse），即 $ MSE = \frac{1}{n} \sum_{i = 1}^{n} (y_i - \hat{y}_i)^2 $，这里 $y_i$ 是真实值， $\hat{y}_i$ 是预测值。
优化器：优化器负责依据损失函数反馈的信息调整模型参数，例如常用的 adam 优化器，它结合了多种优化算法的优点，能自适应地调整学习率，使得模型在训练过程中更快更稳定地收敛。当然，还有如随机梯度下降（sgd）等基础优化器可供选择，不同优化器适用于不同场景，需根据实际情况权衡。
评估指标：评估指标用于量化模型在训练和测试阶段的性能表现，为模型改进提供方向。在分类任务中，准确率（accuracy）是常用指标，其计算公式为：$ Accuracy = \frac{TP + TN}{TP + TN + FP + FN} $，其中 $TP$ （True Positive）表示真正例， $TN$ （True Negative）表示真负例， $FP$ （False Positive）表示假正例， $FN$ （False Negative）表示假负例。在实际编译模型时，设置如下：

model.compile(loss='categorical_crossentropy',optimizer='adam',metrics=['accuracy'])

4.3 模型训练

4.3.1 训练模型的方法与参数（如 epochs、batch_size 等）

训练模型是让模型学习数据特征、优化参数以拟合数据的过程。在 Keras 中，使用 fit 方法开启训练之旅。关键参数包括：

epochs：代表训练的轮数，即模型完整遍历数据集的次数。每一轮训练，模型都会基于当前参数对所有数据进行一次前向传播和反向传播更新参数。例如设置 epochs = 10，意味着模型会重复学习数据 10 次，一般来说，随着 epochs 的增加，模型在训练集上的表现会逐渐提升，但可能出现过拟合风险：

model.fit(x_train, y_train, epochs=10)

batch_size：确定每次参与训练的样本数量。由于大规模数据集无法一次性全部载入内存训练，需分批处理。较小的 batch_size 能使模型在每一步更新时更快收敛，但计算开销大；较大的 batch_size 计算效率高，但可能导致收敛变慢或陷入局部最优。如设置 batch_size = 32：

model.fit(x_train, y_train, epochs=10, batch_size=32)

4.3.2 使用训练数据和验证数据进行训练

为监控模型在训练过程中的泛化能力，防止过拟合，通常会划分出一部分数据作为验证集。在 fit 方法中，可通过 validation_data 参数指定验证集数据：

(x_train, y_train), (x_val, y_val) = train_test_split(x_all, y_all, test_size=0.2)
model.fit(x_train, y_train, epochs=10, batch_size=32, validation_data=(x_val, y_val))

这样，在每一轮训练结束后，模型都会在验证集上进行评估，输出验证集的损失值和评估指标值，我们可以据此观察模型是否出现过拟合迹象，如验证集损失值开始上升，而训练集损失值持续下降。

4.3.3 训练过程中的回调函数（Callback）应用

回调函数是在训练过程中的特定阶段自动执行的函数，为模型训练提供了更多灵活性。例如，使用 EarlyStopping 回调函数，它能监控模型在验证集上的性能，一旦发现性能不再提升（如验证损失连续若干个 epoch 未下降），便提前终止训练，避免资源浪费：

from keras.callbacks import EarlyStoppingearly_stopping = EarlyStopping(monitor='val_loss', patience=3)
model.fit(x_train, y_train, epochs=10, batch_size=32, validation_data=(x_val, y_val), callbacks=[early_stopping])

此外，还有如 ModelCheckpoint 回调函数，可在训练过程中定期保存模型，方便后续选取性能最佳的模型：

from keras.callbacks import ModelCheckpointmodel_checkpoint = ModelCheckpoint('best_model.h5', monitor='val_accuracy', save_best_only=True)
model.fit(x_train, y_train, epochs=10, batch_size=32, validation_data=(x_val, y_val), callbacks=[model_checkpoint])

4.4 模型评估与预测

4.4.1 使用测试数据评估模型性能

训练完成后，需使用独立的测试数据评估模型的最终性能，这能真实反映模型在未见过的数据上的泛化能力。使用 evaluate 方法，传入测试数据和真实标签，它将返回模型在测试集上的损失值和评估指标值：

loss, accuracy = model.evaluate(x_test, y_test)
print(f"Test loss: {loss}, Test accuracy: {accuracy}")

4.4.2 模型预测的方法与应用

当模型训练评估完毕，便可用于实际预测。对于分类任务，使用 predict 方法输入新的数据样本，模型将输出每个样本属于各个类别的预测概率：

predictions = model.predict(x_new)

若需得到最终的类别预测结果，可结合 argmax 函数选取概率最大的类别：

predicted_classes = np.argmax(predictions, axis=1)

对于回归任务，模型直接输出预测的数值：

predictions = model.predict(x_new)

4.5 案例：使用序贯模型进行 MNIST 手写数字识别

4.5.1 数据集介绍与加载

MNIST 数据集是学习>深度学习领域经典的手写数字图像数据集，包含 60,000 张训练图像和 10,000 张测试图像，图像均为 28×28 的灰度图，对应的标签是 0 - 9 的数字，表示图像中手写数字的真实值。在 Keras 中，可便捷地加载该数据集：

from keras.datasets import mnist(x_train, y_train), (x_test, y_test) = mnist.load_data()

4.5.2 数据预处理步骤

加载后的原始数据需进行预处理才能输入模型训练。首先，将图像数据的形状进行调整，从三维（28, 28, 1）展平为二维（784,），以适配全连接层的输入要求：

x_train = x_train.reshape(-1, 784)
x_test = x_test.reshape(-1, 784)

其次，由于图像像素值为 0 - 255 的整数，需将其归一化到 0 - 1 区间，使模型训练更高效：

x_train = x_train / 255.
x_test = x_test / 255.

对于标签数据，需将其转换为 one - hot 编码形式，以满足多分类交叉熵损失函数的计算要求：

from keras.utils import to_categoricaly_train = to_categorical(y_train)
y_test = to_categorical(y_test)

4.5.3 构建、训练与评估模型的完整代码实现

综合上述步骤，以下是使用序贯模型进行 MNIST 手写数字识别的完整代码：

from keras.models import Sequential
from keras.layers import Dense
from keras.datasets import mnist
from keras.utils import to_categorical# 加载数据集
(x_train, y_train), (x_test, y_test) = mnist.load_data()# 数据预处理
x_train = x_train.reshape(-1, 784) / 255.
x_test = x_test.reshape(-1, 784) / 255.
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)# 构建序贯模型
model = Sequential()
model.add(Dense(units=128, activation='relu', input_dim=784))
model.add(Dense(units=10, activation='softmax'))# 编译模型
model.compile(loss='categorical_crossentropy',optimizer='adam',metrics=['accuracy'])# 训练模型
model.fit(x_train, y_train, epochs=10, batch_size=32, validation_split=0.1)# 评估模型
loss, accuracy = model.evaluate(x_test, y_test)
print(f"Test loss: {loss}, Test accuracy: {accuracy}")

通过运行这段代码，便能构建一个简单的序贯模型对 MNIST 手写数字进行识别，观察模型在测试集上的准确率，还可进一步调整模型结构、参数等来提升性能。