TensorFlow 2.x模型构建全解析：从Sequential到子类化

1. 项目概述：从“搭积木”到“造积木”的模型构建之旅

在TensorFlow 2.x的世界里，构建一个神经网络模型，就像一位工程师面对一堆精密的零件，思考如何将它们组装成一台功能强大的机器。新手常常会一头扎进Sequential()的简单世界里，觉得这就是全部。但当你真正开始处理复杂的输入输出、需要共享层、或者想实现一些天马行空的网络结构时，你会发现，只会“搭积木”是远远不够的。今天，我就以经典的鸢尾花分类任务为例，带你彻底搞懂TensorFlow 2中三种创建模型的核心方法：Sequential模型、函数式API模型和子类化模型。这不仅仅是三种不同的API调用，更是三种截然不同的设计哲学和灵活性层级。理解了它们，你就能从“照着图纸组装”进阶到“自己设计图纸”，甚至“发明新的零件”。无论你是想快速验证一个想法，还是构建一个用于生产的复杂多任务学习系统，这篇文章都能给你一张清晰的路线图。

2. 核心思路拆解：三种方法，三种境界

在动手写代码之前，我们必须先理解这三种方法各自的设计理念和适用场景。这决定了你在项目初期应该选择哪条路，避免在后期陷入重构的泥潭。

2.1 Sequential模型：线性堆叠的“快速通道”

这是最直观、最入门的方法。你可以把它想象成“串糖葫芦”或者“叠汉堡”。模型是一层一层严格按顺序堆叠起来的，数据从第一层流入，经过每一层的处理，最后从最后一层流出。它的数据流是单向的、简单的。

核心特点与适用场景：

• 简单直接：代码最简洁，适合教学、快速原型验证（比如验证一个简单的CNN或MLP想法）。
• 限制明显：无法创建具有多输入、多输出、共享层或残差连接等复杂拓扑结构的模型。如果你的网络需要分支、合并或者循环，它就不够用了。
• 内部黑盒：对于初学者，它隐藏了层与层之间“张量流动”的细节，虽然降低了门槛，但也让你对模型的数据流缺乏直观感受。

在鸢尾花数据集（4个特征，3个类别）上，一个典型的Sequential模型可能就是：输入层（4个神经元） -> 隐藏层（比如10个神经元，ReLU激活） -> 输出层（3个神经元，Softmax激活）。这就是一条笔直的高速公路。

2.2 函数式API模型：灵活连接的“交通网络”

这是TensorFlow/Keras中最强大、最常用的模型构建方式，尤其在生产环境和研究论文中。它把模型看作是由层（Layer）和张量（Tensor）组成的有向无环图（DAG）。你不再按顺序“添加”层，而是像搭乐高一样，显式地定义层与层之间如何连接。

核心特点与适用场景：

• 极致灵活：可以轻松创建多输入、多输出、共享层（例如，两个不同的输入分支共享同一个特征提取器）、以及具有复杂非线性拓扑（如Inception模块、ResNet残差块）的模型。
• 显式数据流：你需要手动定义每一层的输入来自哪个上一层的输出，这迫使你清晰地思考数据的流向，对理解模型内部运作大有裨益。
• 可绘图、可调试：构建好的模型可以方便地绘制出结构图，并且可以像函数一样，将中间任意层的输出“钩”出来查看，便于调试。

对于鸢尾花任务，虽然用函数式API有点“杀鸡用牛刀”，但它能让你清晰地看到：input_tensor->dense_1->dense_2->output_tensor这样一个明确的映射关系。

2.3 子类化模型：随心所欲的“自定义车间”

这是最底层、最灵活的方法。通过继承tf.keras.Model类，并重写__init__和call方法，你可以完全掌控模型的前向传播逻辑。这相当于你不仅设计了零件的连接方式，还自己定义了某些零件的内部工作机制。

核心特点与适用场景：

• 完全自由：你可以实现任何你能想象到的前向传播逻辑，包括动态的、条件性的层（比如根据输入数据的不同，动态决定使用哪条路径），这在研究新型网络结构时是必不可少的。
• 面向对象：将模型封装成一个类，更符合软件工程的思想，便于管理复杂的模型状态和自定义方法。
• 缺点与挑战：失去了函数式API的一些便利性，比如模型结构图可能无法自动绘制得那么完美，需要更小心地处理层的追踪（以便model.summary()和model.save()能正常工作）。

在鸢尾花例子中，子类化看起来可能和Sequential差不多，但其价值在于为未来更复杂的、无法用简单图结构表示的模型打下了基础。

选择建议：对于绝大多数情况，优先使用函数式API。它在灵活性和易用性之间取得了最佳平衡。Sequential用于最简单的场景，子类化则留给那些真正需要“打破常规”的研究或特殊需求。

3. 环境准备与数据加载

工欲善其事，必先利其器。在开始构建模型之前，我们需要一个干净的环境和规整的数据。

3.1 环境配置与库导入

确保你使用的是TensorFlow 2.x。我强烈建议在虚拟环境（如conda或venv）中操作，避免包冲突。

import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers, Model # 导入关键模块 import numpy as np import pandas as pd from sklearn.datasets import load_iris from sklearn.model_selection import train_test_split from sklearn.preprocessing import StandardScaler import matplotlib.pyplot as plt print(f"TensorFlow版本: {tf.__version__}")

注意：这里我们同时导入了layers和Model。layers用于获取各种层（如Dense），而Model类是函数式API和子类化中创建最终模型对象的核心。

3.2 鸢尾花数据集的加载与预处理

鸢尾花数据集是机器学习界的“Hello World”，它包含150个样本，每个样本有4个特征（花萼和花瓣的长宽），属于3个不同的鸢尾花品种。

# 1. 加载数据 iris = load_iris() X = iris.data # 形状 (150, 4) y = iris.target # 形状 (150,)， 值为0, 1, 2 # 2. 数据预处理（非常重要！） # 将标签转换为独热编码（One-hot Encoding），这是多分类问题的标准操作 y_onehot = tf.keras.utils.to_categorical(y, num_classes=3) # 划分训练集和测试集 X_train, X_test, y_train, y_test = train_test_split(X, y_onehot, test_size=0.2, random_state=42) # 特征标准化：让每个特征均值为0，方差为1，加速模型收敛 scaler = StandardScaler() X_train_scaled = scaler.fit_transform(X_train) X_test_scaled = scaler.transform(X_test) # 注意：使用训练集的scaler来转换测试集 print(f"训练集形状: X: {X_train_scaled.shape}, y: {y_train.shape}") print(f"测试集形状: X: {X_test_scaled.shape}, y: {y_test.shape}")

实操心得：

1. 独热编码：对于分类问题的标签，使用to_categorical转换是必须的，因为我们的输出层使用Softmax激活，它期望每个样本的标签是一个概率分布向量（如[1,0,0]）。
2. 标准化：对于像鸢尾花这样特征尺度不一的数据（花瓣长度可能几十毫米，花萼宽度可能几毫米），标准化能极大提升梯度下降的效率和模型稳定性。切记，StandardScaler的fit只能在训练集上进行，然后用同样的参数去转换测试集，这是数据泄露的经典陷阱。
3. 随机种子：设置random_state可以确保每次运行代码时，数据集的划分是一致的，这对于结果复现至关重要。

4. 方法一：Sequential模型——快速入门之选

现在，让我们用第一种，也是最简单的方法来构建模型。

4.1 模型的构建与编译

# 方法1: Sequential API def create_sequential_model(): model = keras.Sequential([ # 第一层需要指定input_shape，后面的层会自动推断输入维度 layers.Dense(units=10, activation='relu', input_shape=(4,)), # 可以添加Dropout层防止过拟合，这里为了示例清晰先不用 # layers.Dropout(0.1), layers.Dense(units=8, activation='relu'), # 输出层：3个神经元，对应3个类别，使用softmax激活输出概率 layers.Dense(units=3, activation='softmax') ]) return model seq_model = create_sequential_model() # 编译模型：指定优化器、损失函数和评估指标 seq_model.compile( optimizer='adam', # 自适应矩估计，最常用的优化器 loss='categorical_crossentropy', # 多分类交叉熵损失，与softmax和独热编码配套使用 metrics=['accuracy'] # 监控准确率 ) # 查看模型结构 seq_model.summary()

运行summary()，你会看到一个清晰的层结构输出，包括每层的输出形状和参数数量。你会发现，第一层的参数数量是(4 * 10) + 10 = 50，其中4是输入特征数，10是本层神经元数，加上的10是偏置项。

4.2 模型训练与评估

# 训练模型 history_seq = seq_model.fit( X_train_scaled, y_train, validation_split=0.15, # 从训练集中再分一部分作为验证集，用于监控训练过程 epochs=50, # 训练轮数 batch_size=16, # 批大小 verbose=1 # 显示进度条 ) # 在测试集上评估模型 test_loss, test_acc = seq_model.evaluate(X_test_scaled, y_test, verbose=0) print(f"\nSequential模型测试集准确率: {test_acc:.4f}")

注意事项：

• validation_split：这是一个非常方便的参数，它会在每个epoch结束后，用这部分数据评估模型，但不参与训练。你可以通过history对象查看训练和验证损失/准确率的变化，这是判断模型是否过拟合的关键。
• batch_size：太小会导致训练慢且不稳定，太大可能会内存不足。一般从16、32、64开始尝试。对于小数据集（如鸢尾花），16或32比较合适。
• epochs：不要盲目设置很大。通过观察history，当验证集损失不再下降甚至开始上升时（过拟合），就应该提前停止训练。我们可以用简单的绘图来观察。

# 绘制训练历史 def plot_history(history, title): fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4)) fig.suptitle(title) # 绘制损失 ax1.plot(history.history['loss'], label='训练损失') ax1.plot(history.history['val_loss'], label='验证损失') ax1.set_xlabel('Epoch') ax1.set_ylabel('Loss') ax1.legend() ax1.grid(True) # 绘制准确率 ax2.plot(history.history['accuracy'], label='训练准确率') ax2.plot(history.history['val_accuracy'], label='验证准确率') ax2.set_xlabel('Epoch') ax2.set_ylabel('Accuracy') ax2.legend() ax2.grid(True) plt.show() plot_history(history_seq, "Sequential模型训练历史")

通过图表，你可以清晰地看到模型在训练集和验证集上的表现。理想情况是两条曲线都下降并趋于平稳，且差距不大。如果训练损失持续下降而验证损失上升，就是典型的过拟合。

5. 方法二：函数式API模型——灵活强大的主力军

接下来，我们使用函数式API来构建一个结构上相同，但理念完全不同的模型。

5.1 模型的构建与连接

# 方法2: 函数式API def create_functional_model(): # 1. 定义输入层。注意，这里创建的是一个“输入张量”的规范，而不是数据本身。 inputs = keras.Input(shape=(4,), name='iris_input') # name参数便于区分 # 2. 以函数调用的方式，将上一层的输出作为下一层的输入 x = layers.Dense(10, activation='relu', name='dense_1')(inputs) x = layers.Dense(8, activation='relu', name='dense_2')(x) # 3. 定义输出层 outputs = layers.Dense(3, activation='softmax', name='predictions')(x) # 4. 通过指定输入和输出张量来创建模型 model = Model(inputs=inputs, outputs=outputs, name='functional_iris_model') return model func_model = create_functional_model() func_model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) func_model.summary()

你会发现，summary()的输出和Sequential模型几乎一样。但背后的构建逻辑天差地别。这里的inputs,x,outputs都是张量，Model对象通过追踪从inputs到outputs的所有计算路径，构建了整个计算图。

5.2 函数式API的独特优势：多输入输出与层共享

为了展示函数式API的真正威力，我们假设一个（有点牵强但为了演示）更复杂的场景：我们不仅使用原始的4个特征，还想额外加入两个由原始特征计算出来的“人工特征”（例如长宽比）。

# 演示函数式API处理多输入 def create_multi_input_functional_model(): # 输入1: 原始4个特征 input_original = keras.Input(shape=(4,), name='input_original') # 输入2: 2个人工特征（假设是花萼长宽比和花瓣长宽比） input_engineered = keras.Input(shape=(2,), name='input_engineered') # 分支1：处理原始特征 x1 = layers.Dense(6, activation='relu')(input_original) # 分支2：处理人工特征 x2 = layers.Dense(4, activation='relu')(input_engineered) # 合并两个分支 concatenated = layers.concatenate([x1, x2], name='merge_features') # 合并后继续处理 x = layers.Dense(8, activation='relu')(concatenated) outputs = layers.Dense(3, activation='softmax')(x) # 创建模型，指定多个输入 model = Model(inputs=[input_original, input_engineered], outputs=outputs, name='multi_input_model') return model # 为了演示，我们创建一些虚拟的人工特征数据（实际项目中需要真实计算） # 例如，用花萼长/宽和花瓣长/宽作为人工特征 X_train_eng = X_train_scaled[:, [0, 2]] / (X_train_scaled[:, [1, 3]] + 1e-7) # 防止除零 X_test_eng = X_test_scaled[:, [0, 2]] / (X_test_scaled[:, [1, 3]] + 1e-7) multi_input_model = create_multi_input_functional_model() multi_input_model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) multi_input_model.summary() # 训练时需要传入匹配的输入数据列表 history_multi = multi_input_model.fit( [X_train_scaled, X_train_eng], y_train, # 输入是两个数组的列表 validation_split=0.15, epochs=50, batch_size=16, verbose=0 ) test_loss_multi, test_acc_multi = multi_input_model.evaluate([X_test_scaled, X_test_eng], y_test, verbose=0) print(f"\n多输入函数式模型测试集准确率: {test_acc_multi:.4f}")

核心要点：

• 层共享：函数式API可以轻松实现层共享。例如，你可以定义一层shared_dense = layers.Dense(64, activation='relu')，然后在模型的不同分支中调用shared_dense(branch1)和shared_dense(branch2)。这两个分支将共享完全相同的权重，这在Siamese网络或多任务学习中非常常见。
• 模型作为层：你可以将一个训练好的模型（Model实例）当作一个“大层”来使用，这在迁移学习和构建复杂系统时极其有用。
• 中间层输出：你可以轻松获取中间任何层的输出，用于可视化特征或构建多输出模型。

  # 创建一个新模型，输出指定中间层的激活值 feature_extractor = Model(inputs=func_model.input, outputs=func_model.get_layer('dense_1').output) features = feature_extractor.predict(X_test_scaled[:5]) print("前5个样本在‘dense_1’层的特征形状：", features.shape)

6. 方法三：子类化模型——终极自由的定制工具

最后，我们进入最灵活的领域。子类化模型要求你对面向对象编程有基本的了解。

6.1 继承tf.keras.Model类

# 方法3: 子类化API class IrisSubclassModel(tf.keras.Model): def __init__(self, units1=10, units2=8, num_classes=3): # 调用父类的初始化方法 super(IrisSubclassModel, self).__init__() # 在__init__中定义所有层 self.dense1 = layers.Dense(units1, activation='relu') self.dense2 = layers.Dense(units2, activation='relu') self.predictions = layers.Dense(num_classes, activation='softmax') # 定义前向传播过程 def call(self, inputs, training=False): # 这里可以编写任意复杂的前向传播逻辑 x = self.dense1(inputs) x = self.dense2(x) # 如果在训练阶段，你可以在这里添加Dropout等行为 # if training: # x = tf.nn.dropout(x, rate=0.1) return self.predictions(x) # 可选：为了能让summary()正常工作，需要定义build方法或指定input_shape def build(self, input_shape): # 这个方法会在模型第一次看到输入数据时被调用，用于动态构建层的权重。 # 对于简单的层，通常不需要显式重写，因为Dense层自己会处理。 # 这里我们显式调用一下，确保层被构建。 super(IrisSubclassModel, self).build(input_shape) # 实例化模型 subclass_model = IrisSubclassModel() # 在编译或调用build之前，模型没有权重，summary可能报错。 # 我们需要先构建它（通过传入一个虚拟输入或调用build） subclass_model.build(input_shape=(None, 4)) # None是batch维度 subclass_model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) subclass_model.summary()

6.2 子类化的高级用法：动态前向传播

子类化的真正威力在于call方法。你可以在这里写Python控制流（if-else, for循环）。

class DynamicSubclassModel(tf.keras.Model): def __init__(self): super(DynamicSubclassModel, self).__init__() self.dense_small = layers.Dense(5, activation='relu') self.dense_large = layers.Dense(15, activation='relu') self.dense_final = layers.Dense(3, activation='softmax') def call(self, inputs, training=False): # 动态逻辑：如果输入的第一个特征值大于0，走“大”网络，否则走“小”网络 # 注意：这只是为了演示动态性，在实际分类问题中这种设计可能没有意义。 if tf.reduce_mean(inputs[:, 0]) > 0: # 判断批次中第一个特征的均值 x = self.dense_large(inputs) print("Debug: 使用了大型层路径") # 注意：print在eager模式下可见，在graph模式下可能不行 else: x = self.dense_small(inputs) print("Debug: 使用了小型层路径") return self.dense_final(x) # 测试动态模型 dynamic_model = DynamicSubclassModel() dynamic_model.build(input_shape=(None, 4)) # 注意：这种包含Python控制流的模型在转换为SavedModel或TFLite时可能需要特殊处理（使用tf.cond等）

重要警告：在call方法中使用Python的if或print在急切执行（eager execution）模式下可以工作，但当你需要将模型导出、用于TF Serving或转换为TFLite时，必须使用TensorFlow的操作（如tf.cond,tf.print）来保证计算图的可序列化。对于生产环境，建议将动态逻辑用tf.cond重写。

6.3 训练与评估子类化模型

训练子类化模型和之前完全一样。

history_subclass = subclass_model.fit( X_train_scaled, y_train, validation_split=0.15, epochs=50, batch_size=16, verbose=0 ) test_loss_sub, test_acc_sub = subclass_model.evaluate(X_test_scaled, y_test, verbose=0) print(f"\n子类化模型测试集准确率: {test_acc_sub:.4f}")

7. 三种方法的对比与总结

我们已经用三种方法实现了同一个任务。现在我们来做一个系统的对比。

个人经验与选择建议：

1. 新手入门：毫不犹豫地从Sequential开始。它能让你快速获得成就感，理解层、激活函数、损失函数等基本概念。
2. 日常开发与研究：将函数式API作为你的默认选择。它几乎能覆盖95%的模型构建需求，在灵活性和便利性之间取得了完美平衡。当你画出一个复杂的网络结构图时，用函数式API来实现通常是最直接的方式。
3. 前沿探索与深度定制：当你的想法无法用“层的有向无环图”来描述时，就该子类化出场了。比如，你想在模型内部实现一个循环（非RNN那种）、一个根据输入数据动态变化的网络结构，或者你想完全自定义训练循环（重写train_step方法），子类化是你的不二之选。

一个常见的误区：很多人学会了子类化就觉得函数式API过时了。绝非如此。函数式API因其清晰、可调试、可序列化的特性，在工程化和团队协作中具有巨大优势。子类化是一把锋利的手术刀，而函数式API是你日常使用的多功能瑞士军刀。

8. 进阶技巧与避坑指南

在实际项目中，仅仅构建模型是不够的。下面分享一些我踩过坑后总结的经验。

8.1 模型保存与加载的差异

三种方法在保存和加载上大部分情况是兼容的，但有一些细微差别。

# 保存模型（H5格式或SavedModel格式） seq_model.save('iris_sequential.h5') # 保存为H5文件 func_model.save('iris_functional') # 保存为SavedModel文件夹（默认，推荐） # 加载模型 loaded_seq_model = keras.models.load_model('iris_sequential.h5') loaded_func_model = keras.models.load_model('iris_functional') # 对于子类化模型，保存时需要特别注意 subclass_model.save('iris_subclass', save_format='tf') # 必须使用SavedModel格式 # 加载时，需要确保自定义的类在当前作用域可访问 loaded_subclass_model = keras.models.load_model('iris_subclass', custom_objects={'IrisSubclassModel': IrisSubclassModel})

重要提示：对于包含自定义层、损失函数或指标的子类化模型，加载时必须通过custom_objects参数将对应的类传递进去，否则TensorFlow无法知道如何重建这个模型对象。

8.2 自定义层与自定义损失函数

当你需要实现一个特殊的激活函数或一个复杂的损失函数时，你就需要自定义。

# 示例：自定义一个简单的层（带L1正则化的Dense层） class L1RegularizedDense(layers.Layer): def __init__(self, units, l1_factor=0.01, **kwargs): super(L1RegularizedDense, self).__init__(**kwargs) self.units = units self.l1_factor = l1_factor def build(self, input_shape): # 创建权重 self.kernel = self.add_weight( name='kernel', shape=(input_shape[-1], self.units), initializer='glorot_uniform', trainable=True ) self.bias = self.add_weight( name='bias', shape=(self.units,), initializer='zeros', trainable=True ) super().build(input_shape) def call(self, inputs): # 前向传播 output = tf.matmul(inputs, self.kernel) + self.bias # 添加L1正则化损失 l1_loss = tf.reduce_sum(tf.abs(self.kernel)) * self.l1_factor self.add_loss(l1_loss) # 关键！将损失添加到层的损失集合中 return output def get_config(self): # 支持序列化 config = super().get_config() config.update({ 'units': self.units, 'l1_factor': self.l1_factor }) return config # 在函数式API中使用自定义层 inputs = keras.Input(shape=(4,)) x = L1RegularizedDense(10, l1_factor=0.01)(inputs) x = layers.Activation('relu')(x) # 可以接标准层 outputs = layers.Dense(3, activation='softmax')(x) custom_layer_model = Model(inputs=inputs, outputs=outputs) custom_layer_model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) # 编译后，自定义层添加的L1损失会自动加入到模型的总损失中

8.3 模型部署与生产化考量

当你需要将模型部署到服务器或移动端时，需要考虑以下几点：

1. 格式选择：SavedModel格式是TensorFlow的标准格式，适用于TF Serving、TFLite、TensorFlow.js等几乎所有部署场景，比H5格式更通用。
2. 图模式 vs 急切模式：子类化模型中复杂的Python逻辑在转换为计算图时可能出错。对于部署，尽量使用函数式API，或者在子类化中使用@tf.function装饰器将call方法转换为静态图。
3. 量化与优化：使用TensorFlow Lite Converter可以对模型进行量化（降低精度以减少模型大小和加速推理），这对移动端和嵌入式设备至关重要。
4. 签名定义：对于服务化部署（如TF Serving），你需要明确定义模型的输入和输出签名，这在函数式API中非常直观。

9. 常见问题排查与调试技巧

即使经验丰富，调试模型构建过程也是家常便饭。这里列出几个最常见的问题和解决方法。

问题1：ValueError: The first layer in a Sequential model must get aninput_shapeorbatch_input_shapeargument.

• 原因：Sequential模型的第一层没有指定输入形状。
• 解决：在第一层的参数中添加input_shape，例如Dense(10, input_shape=(4,))。

问题2：TypeError: The added layer must be an instance of class Layer.

• 原因：试图向Sequential模型添加的不是一个Layer对象。
• 解决：检查你添加的是否是keras.layers中的层，或者是否正确实例化了自定义层。

问题3：函数式API中报错，提示张量形状不匹配。

• 原因：层与层之间的张量维度对不上。比如上一层的输出是(None, 5)，下一层期望的输入是(None, 10)。
• 解决：使用model.summary()或print(layer.output_shape)仔细检查每一层的输出形状。确保连接正确。

问题4：子类化模型无法保存，或保存后加载失败。

• 原因：最常见的是没有正确实现get_config方法，或者加载时没有提供custom_objects。
• 解决：
  1. 确保自定义的Layer或Model子类实现了get_config和from_config方法（或至少get_config）。
  2. 保存时使用save_format='tf'。
  3. 加载时，务必在custom_objects字典中提供所有自定义类。

问题5：训练时损失为NaN。

• 原因：学习率太高、数据未标准化、存在异常值、最后一层激活函数与损失函数不匹配（如用Sigmoid配MSE在多分类上）。
• 解决：
  1. 检查数据预处理，确保标准化/归一化。
  2. 降低学习率（例如从1e-3降到1e-4）。
  3. 检查损失函数和输出层激活函数是否匹配（分类：Softmax + 交叉熵；二分类：Sigmoid + 交叉熵；回归：通常无激活 + MSE/MAE）。

调试技巧：

• 使用tf.debugging：在代码中插入tf.debugging.check_numerics来追踪NaN或Inf值的出现位置。
• 小批量数据运行：先用一个很小的批次（比如2个样本）运行一次前向传播，确保模型能跑通，再开始正式训练。
• 绘制计算图：对于函数式API模型，tf.keras.utils.plot_model函数可以生成一张漂亮的网络结构图，帮助你直观理解连接关系。