3.2 构建神经网络模型

3.2 构建神经网络模型

TensorFlow Keras 高级 API：构建神经网络模型

1. Sequential 模型

Sequential 模型是最简单、最直接的模型构建方式。它适用于构建层与层之间顺序连接的线性堆叠模型。

1.1 模型定义

使用 Sequential 模型，你可以简单地将各个层按顺序添加到模型中。

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
# 定义一个 Sequential 模型
model = keras.Sequential([
    layers.Dense(64, activation='relu', input_shape=(784,)), # 输入层，指定输入维度
    layers.Dense(10, activation='softmax') # 输出层
])
​

1.2 模型结构可视化

1.3 添加层

除了在创建模型时添加层，你也可以使用 add() 方法动态地添加层。

model = keras.Sequential()
model.add(layers.Dense(64, activation='relu', input_shape=(784,)))
model.add(layers.Dense(10, activation='softmax'))
​

1.4 模型配置

在构建模型后，你需要配置模型的优化器、损失函数和评估指标。

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

1.5 模型训练

使用 fit() 方法训练模型。

# 假设你有训练数据 x_train 和 y_train
model.fit(x_train, y_train, epochs=5, batch_size=32)
​

1.6 模型评估

使用 evaluate() 方法评估模型在测试集上的性能。

# 假设你有测试数据 x_test 和 y_test
loss, accuracy = model.evaluate(x_test, y_test)
print('Test accuracy:', accuracy)
​

2. Functional API

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

2.1 模型定义

使用 Functional API，你需要定义模型的输入和输出，并将各个层连接起来。

# 定义输入层
input_layer = keras.Input(shape=(784,))
# 定义中间层
dense1 = layers.Dense(64, activation='relu')(input_layer)
dense2 = layers.Dense(10, activation='softmax')(dense1)
# 定义模型
model = keras.Model(inputs=input_layer, outputs=dense2)
​

2.2 模型结构可视化

2.3 多输入模型

# 定义两个输入层
input_a = keras.Input(shape=(32,))
input_b = keras.Input(shape=(64,))
# 定义共享层
shared_dense = layers.Dense(16, activation='relu')
# 连接输入层和共享层
dense_a = shared_dense(input_a)
dense_b = shared_dense(input_b)
# 合并两个分支
merged = layers.concatenate([dense_a, dense_b])
# 定义输出层
output = layers.Dense(1, activation='sigmoid')(merged)
# 定义模型
model = keras.Model(inputs=[input_a, input_b], outputs=output)
​

2.4 多输出模型

# 定义输入层
input_layer = keras.Input(shape=(784,))
# 定义中间层
dense1 = layers.Dense(64, activation='relu')(input_layer)
# 定义两个输出层
output_a = layers.Dense(10, activation='softmax', name='output_a')(dense1)
output_b = layers.Dense(1, activation='sigmoid', name='output_b')(dense1)
# 定义模型
model = keras.Model(inputs=input_layer, outputs=[output_a, output_b])
​

2.5 模型配置、训练和评估

与 Sequential 模型类似，你需要配置、训练和评估 Functional API 构建的模型。

model.compile(optimizer='adam',
              loss={'output_a': 'categorical_crossentropy', 'output_b': 'binary_crossentropy'},
              metrics=['accuracy'])
# 假设你有训练数据 input_data 和 output_data
model.fit(input_data, output_data, epochs=5, batch_size=32)
# 假设你有测试数据 input_test 和 output_test
loss, accuracy = model.evaluate(input_test, output_test)
print('Test accuracy:', accuracy)
​

3. Model Subclassing

Model Subclassing 提供了最大的灵活性，允许你完全自定义模型的前向传播过程。你需要继承 tf.keras.Model 类，并在 __init__ 方法中定义模型的层，在 call 方法中定义模型的前向传播过程。

3.1 模型定义

class MyModel(keras.Model):
    def __init__(self, num_units=64, num_classes=10):
        super(MyModel, self).__init__()
        self.dense1 = layers.Dense(num_units, activation='relu')
        self.dense2 = layers.Dense(num_classes, activation='softmax')
    def call(self, inputs):
        x = self.dense1(inputs)
        return self.dense2(x)
# 创建模型实例
model = MyModel(num_units=64, num_classes=10)
​

3.2 模型结构可视化

由于 Model Subclassing 的灵活性，难以用简单的图示来表示，其结构完全取决于 call 方法中的逻辑。

3.3 自定义层

你可以在 Model Subclassing 中使用自定义层，进一步扩展模型的功能。

class MyLayer(layers.Layer):
    def __init__(self, units=32):
        super(MyLayer, self).__init__()
        self.units = units
    def 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='zeros',
                                 trainable=True)
    def call(self, inputs):
        return tf.matmul(inputs, self.w) + self.b
class MyModelWithCustomLayer(keras.Model):
    def __init__(self, num_units=64, num_classes=10):
        super(MyModelWithCustomLayer, self).__init__()
        self.mylayer = MyLayer(units=num_units)
        self.dense2 = layers.Dense(num_classes, activation='softmax')
    def call(self, inputs):
        x = self.mylayer(inputs)
        return self.dense2(x)
model = MyModelWithCustomLayer(num_units=64, num_classes=10)
​

3.4 模型配置、训练和评估

与 Sequential 和 Functional API 类似，你需要配置、训练和评估 Model Subclassing 构建的模型。

model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])
# 假设你有训练数据 x_train 和 y_train
model.fit(x_train, y_train, epochs=5, batch_size=32)
# 假设你有测试数据 x_test 和 y_test
loss, accuracy = model.evaluate(x_test, y_test)
print('Test accuracy:', accuracy)
​

4. 模型构建方法的选择

• Sequential 模型： 适用于简单的线性堆叠模型，易于使用和理解。

• Functional API： 适用于更复杂的模型，例如多输入、多输出、共享层和残差连接等。

• Model Subclassing： 适用于需要完全自定义模型前向传播过程的场景，灵活性最高。

选择哪种方法取决于你的模型复杂度和对灵活性的需求。对于简单的模型，Sequential 模型可能就足够了。对于更复杂的模型，Functional API 或 Model Subclassing 可能更适合。

5. 总结

TensorFlow Keras 提供了多种构建神经网络模型的方式，每种方法都有其优缺点。通过本文的介绍，你应该能够根据自己的需求选择合适的模型构建方法，并使用 Keras 简洁高效地构建各种神经网络模型。 掌握这些方法对于深入学习和应用深度学习至关重要。