TeamClass_MD/Topic1/teach_Tensorflow.md

深度学习的实现

在TensorFlow中实现

import numpy as np
import tensorflow as tf
from keras import layers, models
from keras.datasets import mnist
from keras.utils import to_categorical
# 加载MNIST数据集
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

# 数据预处理
train_images = train_images.reshape((60000, 28 * 28)).astype('float32') / 255
test_images = test_images.reshape((10000, 28 * 28)).astype('float32') / 255

train_labels = to_categorical(train_labels)
test_labels = to_categorical(test_labels)

# 定义模型
model = models.Sequential()
model.add(layers.Dense(64, activation='relu', input_shape=(28 * 28,)))
model.add(layers.Dense(10, activation='softmax'))  # 注意这里需要指定输出层的神经元数量

# 编译模型
optimizer = tf.keras.optimizers.Adam()  # 正确的导入方式
loss = 'categorical_crossentropy'
metrics = ['accuracy']
model.compile(optimizer=optimizer, loss=loss, metrics=metrics)

# 训练模型
model.fit(train_images, train_labels, epochs=5, batch_size=32)

# 评估模型
test_loss, test_acc = model.evaluate(test_images, test_labels)
print(f"Test accuracy: {test_acc}")

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

在TensorFlow中实现深度学习需要以下步骤：

数据准备 → 模型定义 → 编译 → 训练（自动/自定义） → 评估 → 保存/部署

模型的定义

• 在深度学习中，模型定义（Model Definition） 是构建神经网络的核心步骤，目的是明确模型的结构和数据流动方式。它决定了神经网络由哪些层组成、层与层之间如何连接，以及每层的计算逻辑。可以类比为设计一栋建筑的蓝图，需要明确房间（层）的布局、连接方式（数据流）和每个房间的功能（层的计算规则）。
• 模型定义的三个核心问题
  • 模型的结构是什么？
    • 有多少层？每一层的类型（全连接层、卷积层等）是什么？
  • 层之间如何连接？
    • 是简单的线性堆叠（如Sequential模型），还是存在分支、跳跃连接等复杂拓扑？
  • 每层具体做什么？
    • 每层的参数（如神经元数量、滤波器大小）、激活函数、正则化方法等。
• TensorFlow（尤其是其高层 API tf.keras）提供了多种定义模型的方法。
• Sequential模型：适用于简单的线性堆叠结构，即每一层直接连接到下一层。

import tensorflow as tf
from tensorflow.keras import layers, models

# 定义模型
model = models.Sequential() #创建了一个Sequential模型。Sequential模型允许我们一层一层地构建网络，每层都是顺序堆叠的。

model.add(layers.Dense(64, activation='relu', input_shape=(784,))) 
#添加第一个全连接层（Dense）到模型中：该层有64个神经元。使用的激活函数是ReLU（Rectified Linear Unit），它是一种常用的非线性激活函数。指定输入数据的形状。这里假设输入数据是784个特征，这对应于一个28x28像素的图像展平后的结果。

model.add(layers.Dense(64, activation='relu')) 
#添加第二个全连接层：这个层同样有64个神经元，并且使用ReLU激活函数。由于这是第二个层，不需要指定输入形状，因为它自动从上一层获取。

model.add(layers.Dense(10, activation='softmax')) 
#最后一个全连接层：这个层有10个神经元，通常用于分类任务，每个神经元对应一个类别。使用softmax激活函数，它将神经元的输出转换为概率分布，总和为1。它可以解释为每个类别的预测概率。

• 函数式API：适用于更复杂的模型结构，如非顺序的层连接、共享层、多输入多输出模型等。

  • 适用场景：复杂模型（多输入/输出、分支、跳跃连接、共享层）。
  • 特点：显式定义输入和输出，灵活构建层间连接关系。
  • 代码示例（多输入模型）：

  # 定义输入层
  input1 = tf.keras.Input(shape=(32,), name="input_1")
  input2 = tf.keras.Input(shape=(64,), name="input_2")
  
  # 合并两个输入
  concatenated = tf.keras.layers.Concatenate()([input1, input2])
  
  # 定义中间层
  x = tf.keras.layers.Dense(128, activation='relu')(concatenated)
  x = tf.keras.layers.Dropout(0.5)(x)
  
  # 定义输出层
  output = tf.keras.layers.Dense(1, activation='sigmoid')(x)
  
  # 创建模型
  model = tf.keras.Model(inputs=[input1, input2], outputs=output)`
  

• 子类化API：适用于需要完全控制模型结构和训练过程的场景，可以自定义前向传播逻辑和训练循环。

  • 适用场 景：需要完全自定义的模型（如动态计算图、自定义前向逻辑）。
  • 特点：通过继承 tf.keras.Model 类，自由定义前向传播逻辑。适用于需要高度自定义的模型结构。
  • 代码示例（自定义模型）：

    class CustomModel(tf.keras.Model):
      def __init__(self):
          super().__init__()
          # 定义层
          self.dense1 = tf.keras.layers.Dense(64, activation='relu')
          self.dropout = tf.keras.layers.Dropout(0.2)
          self.dense2 = tf.keras.layers.Dense(10, activation='softmax')
    
      def call(self, inputs, training=False):
          # 自定义前向传播逻辑
          x = self.dense1(inputs)
          if training:  # 仅在训练时使用Dropout
              x = self.dropout(x)
          return self.dense2(x)
    
      # 实例化模型并构建
      model = CustomModel()
      model.build(input_shape=(None, 784))  # 指定输入形状
    

  • 优点：
    • 完全控制模型逻辑（如条件分支、循环操作）。
    • 支持动态计算（如根据输入数据调整结构）。
  • 缺点：
    • 代码复杂度高，需手动管理层和参数。
    • 模型结构不易可视化（如model.summary()需先调用build）。

• 中间层都有不同的类型，例如：

  • Dense层：全连接层，每个神经元与前一层的所有神经元相连。
  • Dropout层：在训练过程中随机丢弃一部分神经元，以防止过拟合。
  • Flatten层：将输入展平为一维向量，通常用于从卷积层到全连接层的转换。
  • Conv2D层：二维卷积层，用于处理图像数据。
  • MaxPooling2D层：最大池化层，用于降低特征图的维度。
  • BatchNormalization层：批量归一化层，用于加速训练并提高模型的稳定性。
  • Activation层：激活函数层，用于引入非线性变换。

• activation里面指的是使用什么激活函数，比如relu、sigmoid、softmax等

任务类型	推荐激活函数	理由
二分类输出层	Sigmoid、Softmax	输出概率形式。
多分类输出层	Softmax	强制归一化为概率分布。
隐藏层（通用）	ReLU、Leaky ReLU、Swish	平衡性能与计算效率。
RNN/序列模型	Tanh、ELU	稳定梯度传播，缓解长程依赖问题。
需要平滑输出	Softsign、Softmax	输出连续且可解释。
嵌入式设备	Hard Sigmoid、ReLU6	计算快速，硬件友好。
详情请见激活函数

模型的编译

• 在TensorFlow中，​编译阶段的核心API是 tf.keras.Model.compile()，它允许你配置模型的训练参数。
• 1.核心API：model.compile()

  optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
  loss = SparseCategoricalCrossentropy(from_logits=True)
  model.compile(
      optimizer=optimizer,
      loss=loss,
      metrics=['accuracy'], #模型评估时使用的指标列表，在 model.fit() 的输出中，会实时显示这些指标的训练/验证值。model.evaluate() 会返回所有指标的值。
  
      # 其他可选参数
  )
  

参数	说明
optimizer	优化器对象（字符串或实例），控制梯度下降策略。
loss	损失函数（字符串、可调用对象或损失类实例）。
metrics	评估指标列表（字符串、可调用对象或指标类实例）。
loss_weights	字典或列表，为不同输出指定损失权重。
run_eagerly	布尔值，启用急切执行模式（默认False）。

• 2.优化器（optimizer）

• 优化器决定了模型如何更新其参数以最小化损失函数。具体请见优化器。

• 3.损失函数（loss）

• 损失函数衡量模型预测值与真实值之间的差异。具体请见损失函数。

模型的训练

• 在TensorFlow中训练深度学习模型的核心API可分为以下几类：

1. 自动训练 API

• model.fit()
  • 作用: 简化训练流程，自动处理数据迭代、前向传播、反向传播和参数更新。
  • 示例:

    model.fit(train_dataset, epochs=10, validation_data=val_dataset,
    callbacks=[TensorBoard(log_dir='./logs')])

• 关键参数: epochs, batch_size, validation_split, callbacks。

1. epochs（训练轮数）**

• 定义: 每次遍历全部训练数据称为一个 Epoch。
• 目的: 控制模型的学习次数，防止欠拟合（训练不足）或过拟合（训练过度）。
• 调整策略
• 推荐范围:
  • 初期实验: 5~50（根据数据量调整）。
  • 复杂任务（如 ImageNet）: 100~300。
• 注意:
  • 数据量小时（如 MNIST），epochs=10~20 可能已过拟合。
  • 使用 早停回调（EarlyStopping）动态终止训练。
  • 示例:

    model.fit(..., epochs=100, callbacks=[EarlyStopping(patience=10)])
    

  “数据不够，正则来凑；模型太深，Dropout 伺候；早停法防过拟，Epoch 要看数据够不够！”

2. batch_size（批量大小

• 定义: 每次梯度更新使用的样本数量。

• 影响:

• 内存消耗: batch_size 越大，占用的 GPU/TPU 内存越多。

• 收敛速度: 较大的 batch_size 可能加速训练，但梯度更新更粗糙。

• 泛化性能: 小批量（如 32~128）通常泛化效果更好。

• 默认值

  • 32

• 调整策略

  • 硬件限制:
  • GPU 内存充足时，可尝试 batch_size=256 或更大。
  • 内存不足时，降低至 batch_size=16 或 32。

• 经验规则:

  • 小批量: 32~128（适合大多数场景，平衡速度与泛化）。
  • 大批量: 256~1024（需搭配学习率调整，如线性 warmup）。

• 示例:

  model.fit(..., batch_size=64)  # 使用 64 个样本更新一次权重
  

• 高级技巧

  • 动态调整: 使用 tf.data.Dataset 的 prefetch 和 cache 加速数据管道。

3. validation_split（验证集划分比例）**
   • 功能: 在训练数据中按比例自动划分验证集，无需手动拆分 X_train 和 y_train。
   • 默认值: 0.0（不划分验证集）。

• 调整策略
• 推荐值:
  • 0.1~0.2（常用 20% 数据作为验证集）。
• 适用场景:
  • 小型数据集: 避免划分过多验证数据导致训练不足。
  • 大型数据集: 可结合 validation_data 参数指定独立验证集。
• 示例:

  model.fit(..., validation_split=0.2)  # 20% 训练数据作为验证集
  

4. callbacks（回调函数列表）**

• 功能: 在训练过程中插入自定义操作（如保存模型、监控指标、动态调整参数）。

• 默认值: None（不启用任何回调）。

• 常用回调及场景

回调类	作用	示例代码
ModelCheckpoint	保存最佳模型	ModelCheckpoint('best_model.keras', save_best_only=True)
EarlyStopping	根据验证指标提前终止训练	EarlyStopping(monitor='val_loss', patience=3)
TensorBoard	可视化训练过程	TensorBoard(log_dir='./logs')
ReduceLROnPlateau	动态降低学习率（当指标不再提升时）	ReduceLROnPlateau(factor=0.1, patience=2)
CSVLogger	记录训练日志到 CSV 文件	CSVLogger('training.log')

• 自定义回调
  • 实现方式: 继承 tf.keras.callbacks.Callback 类并重写 on_epoch_end 等方法。

  class CustomCallback(tf.keras.callbacks.Callback):
      def on_epoch_end(self, epoch, logs=None):
          print(f"Epoch {epoch}: Custom action here")
  

• 参数综合配置示例

  model.fit(
      train_dataset,
      epochs=100,
      batch_size=64,
      validation_split=0.2,
      callbacks=[
          EarlyStopping(monitor='val_loss', patience=10),
          ModelCheckpoint('best_model.keras', save_best_only=True),
          TensorBoard(log_dir='./logs')
      ]
  )
  

---

2. 自定义训练控制

• 自定义训练控制的核心逻辑

• ​1. 继承 tf.keras.Model 类

  • Keras 的 Model 类封装了神经网络的前向传播、损失计算、梯度更新等核心逻辑。通过继承它，保留这些自动化功能，同时插入自定义代码。

• ​关键方法:

  • __init__: 初始化模型结构（如层）。
  • call(self, inputs, training=None): 定义前向传播逻辑。
  • train_step(self, data): 重写此方法以控制单步训练流程。

• ​2. 重写 train_step 方法

  • ​默认行为:

    1. 执行前向传播（self.call()）  
    2. 计算损失（self.compiled_loss）  
    3. 记录梯度（tf.GradientTape）  
    4. 应用优化器（self.optimizer.apply_gradients）  
    5. 更新指标（self.metrics.update_state）  
    

  • ​自定义点:
    • 在重写时，可以插入额外操作（如梯度裁剪、动态权重更新、自定义损失计算）。

---

3. 分布式训练

• tf.distribute 模块
  • 作用: 在多设备（GPU/TPU）或多节点上并行训练。
  • 常用策略:
    ◦ MirroredStrategy: 单机多GPU同步训练。

strategy = tf.distribute.MirroredStrategy()
with strategy.scope():
    model = build_model()

◦ MultiWorkerMirroredStrategy: 多机多GPU异步训练。

---

4. 高级训练工具

• tf.keras.callbacks
  • 作用: 在训练过程中注入额外操作（如保存模型、早停、可视化）。
  • 常用回调类:
    ◦ ModelCheckpoint: 保存最佳模型。
    ◦ EarlyStopping: 根据验证指标提前终止训练。
    ◦ TensorBoard: 可视化训练过程。
  • 示例:

• callbacks = [
      ModelCheckpoint('best_model.keras', save_best_only=True),
      EarlyStopping(monitor='val_loss', patience=3)
  ]
  

5. 数据管道优化

• tf.data.Dataset API
  • 作用: 高效加载和处理数据，支持并行数据预处理和缓存。
  • 常用方法:
    ◦ map(): 并行应用数据转换函数。
    ◦ shuffle(): 打乱数据顺序。
    ◦ batch(): 分批次处理数据。
  • 示例:

• dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
  dataset = dataset.shuffle(buffer_size=10000).batch(32).prefetch(tf.data.AUTOTUNE)
  

---

总结表

API	用途	典型场景
model.fit()	自动训练流程	快速原型开发
model.train_step()	自定义单步训练逻辑	特殊损失函数或梯度操作
tf.distribute	多设备/多节点分布式训练	大规模模型或硬件资源充足的环境
tf.keras.callbacks	训练过程增强	模型保存、早停、可视化
tf.data.Dataset	数据加载与预处理	高效数据管道构建

模型的评估

1. 核心评估API

(1) model.evaluate()

• 功能：对模型在指定数据集上的性能进行综合评估。
• 示例：

  # 假设 model 是已编译的模型，test_dataset 是测试数据集
  results = model.evaluate(test_dataset, verbose=2)
  print(f"Test loss: {results[0]}, Test accuracy: {results[1]}")
  

• 参数：
  • x/y：输入数据和标签（适用于小批量数据）。
  • dataset：tf.data.Dataset对象（推荐大数据集）。
  • callbacks：训练回调函数（如TensorBoard）。
  • verbose：控制输出详细程度。

---

2. 预定义评估指标

TensorFlow内置了多种评估指标，可直接在模型编译或单独调用中使用。

(1) 在模型编译中添加指标

from tensorflow.keras import metrics

model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=[metrics.Accuracy(), metrics.Precision(name='precision'), metrics.Recall(name='recall')]
)

• 常用指标：
  • Accuracy（准确率）
  • Precision（精确率）
  • Recall（召回率）
  • AUC（ROC曲线下面积）
  • MeanSquaredError（均方误差）

(2) 单独计算指标

通过tf.keras.metrics动态计算指标：

# 计算预测结果
predictions = model.predict(test_dataset, verbose=0)

# 计算准确率
accuracy = metrics.Accuracy()
accuracy.update_state(y_true, y_pred)
print(f"Custom Accuracy: {accuracy.result().numpy()}")

Keras 是什么？

• Keras 是一个高级神经网络API，最初由 François Chollet 于2015年独立开发，旨在简化深度学习模型的构建和训练过程。2017年，TensorFlow 官方将其整合为 tf.keras，成为 TensorFlow 的核心高阶接口。他的优势是：
• 提供直观的接口（如 Sequential 和 Functional API），无需手动编写复杂的前向传播或反向传播代码。
• 内置大量预训练模型和预训练权重，方便迁移学习和微调。
• 支持多种硬件加速，包括 GPU 和 TPU。
• 模型训练和评估的代码简洁易读，便于调试和优化。

Keras 的核心概念

• 模型（Model）：神经网络的基本结构，可以是顺序模型（Sequential）或函数式模型（Functional）。
• 层（Layer）：神经网络的基本单元，如全连接层（Dense）、卷积层（Conv2D）、池化层（MaxPooling2D）等。
• 激活函数（Activation Function）：引入非线性，如 ReLU、sigmoid、softmax 等。
• 损失函数（Loss Function）：衡量模型预测与真实值之间的差异，如均方误差（MSE）、交叉熵（Cross-Entropy）等。
• 优化器（Optimizer）：调整模型参数以最小化损失函数，如 SGD、Adam、RMSprop 等。