TensorFlow 深度学习框架

什么是 TensorFlow？

TensorFlow 是 Google 开发的开源机器学习框架，专门用于构建和训练深度学习模型。简单来说，它就像一个"AI 开发工具箱"，提供了从数据预处理到模型部署的完整解决方案，让开发者能够轻松构建各种人工智能应用。

想象一下，你要建造一座房子。TensorFlow 就像是一套完整的建筑工具和材料，包括锤子、螺丝刀、钢筋、水泥等，还有详细的施工图纸和操作指南。无论你是要建一栋简单的平房，还是复杂的摩天大楼，这套工具都能帮你实现。

为什么选择 TensorFlow？

1. 完整的生态系统

TensorFlow 不仅仅是一个框架，更是一个完整的机器学习生态系统：

核心优势：

易用性：高级 API 让初学者也能快速上手
灵活性：低级 API 满足高级用户的定制需求
可扩展性：支持从手机到数据中心的多种部署环境
社区支持：庞大的开发者社区和丰富的学习资源

2. 强大的计算能力

TensorFlow 在计算性能方面有着显著优势：

硬件支持：

CPU 优化：利用 SIMD 指令集和多核并行
GPU 加速：原生支持 CUDA 和 cuDNN
TPU 支持：专门针对 Google 的 Tensor Processing Unit 优化
分布式训练：支持多机多卡的大规模训练

性能特性：

自动微分：自动计算梯度，简化反向传播
图优化：静态计算图优化，提升执行效率
内存管理：智能内存分配和回收机制
混合精度：支持 FP16 训练，提升速度和内存效率

3. 丰富的应用场景

TensorFlow 几乎可以应用于所有机器学习领域：

TensorFlow 的核心概念

1. 张量（Tensor）

张量是 TensorFlow 中最基本的数据结构，可以理解为多维数组：

张量的属性：

形状（Shape）：每个维度的长度
数据类型（Dtype）：int32, float32, string 等
设备位置（Device）：CPU 或 GPU

2. 计算图（Computational Graph）

TensorFlow 使用计算图来表示机器学习模型：

计算图的特点：

静态图：先定义后执行，便于优化
并行执行：自动识别可并行的操作
内存优化：只在需要时分配内存
跨平台：图可以在不同设备上执行

3. 会话（Session）

会话是执行计算图的运行时环境：

TensorFlow 安装与配置

1. 环境要求

硬件要求：

CPU：支持 AVX 指令集的现代处理器
内存：至少 4GB RAM，推荐 8GB 以上
存储：至少 2GB 可用空间
GPU（可选）：NVIDIA GPU，支持 CUDA 9.0+

软件要求：

Python：3.7-3.11（推荐 3.9）
操作系统：Windows 10+, macOS 10.12+, Ubuntu 16.04+
CUDA（GPU 版本）：9.0-11.8
cuDNN（GPU 版本）：7.6-8.6

2. 安装步骤

使用 pip 安装（推荐）：

# 安装 CPU 版本
pip install tensorflow

# 安装 GPU 版本
pip install tensorflow-gpu

# 安装特定版本
pip install tensorflow==2.12.0

使用 conda 安装：

# 创建虚拟环境
conda create -n tf_env python=3.9

# 激活环境
conda activate tf_env

# 安装 TensorFlow
conda install tensorflow

# 或安装 GPU 版本
conda install tensorflow-gpu

Docker 安装：

# 拉取官方镜像
docker pull tensorflow/tensorflow:latest

# 运行容器
docker run -it tensorflow/tensorflow bash

# GPU 版本
docker run --gpus all -it tensorflow/tensorflow:latest-gpu bash

3. 验证安装

基本验证：

import tensorflow as tf
print("TensorFlow 版本:", tf.__version__)
print("GPU 可用:", tf.config.list_physical_devices('GPU'))

详细测试：

# 创建简单模型测试
import tensorflow as tf
import numpy as np

# 创建数据
x = np.array([[1, 2], [3, 4]], dtype=np.float32)
y = np.array([[2], [4]], dtype=np.float32)

# 创建模型
model = tf.keras.Sequential([
    tf.keras.layers.Dense(1, input_shape=(2,))
])

# 编译模型
model.compile(optimizer='adam', loss='mse')

# 训练模型
model.fit(x, y, epochs=10, verbose=0)

# 预测
predictions = model.predict(x)
print("预测结果:", predictions)

TensorFlow 基础操作

1. 张量操作

创建张量：

import tensorflow as tf

# 从 Python 列表创建
tensor1 = tf.constant([1, 2, 3, 4])
print("一维张量:", tensor1)

# 从 NumPy 数组创建
import numpy as np
array = np.array([[1, 2], [3, 4]])
tensor2 = tf.constant(array)
print("二维张量:", tensor2)

# 创建零张量
zeros = tf.zeros([2, 3])
print("零张量:", zeros)

# 创建单位张量
ones = tf.ones([3, 3])
print("单位张量:", ones)

# 创建随机张量
random = tf.random.normal([2, 2], mean=0, stddev=1)
print("随机张量:", random)

张量运算：

# 基本运算
a = tf.constant([1, 2, 3])
b = tf.constant([4, 5, 6])

# 加法
add_result = tf.add(a, b)
print("加法:", add_result)

# 乘法
mul_result = tf.multiply(a, b)
print("乘法:", mul_result)

# 矩阵乘法
matrix_a = tf.constant([[1, 2], [3, 4]])
matrix_b = tf.constant([[5, 6], [7, 8]])
matmul_result = tf.matmul(matrix_a, matrix_b)
print("矩阵乘法:", matmul_result)

2. 变量和占位符

变量（Variable）：

# 创建变量
w = tf.Variable([1.0, 2.0], name='weights')
b = tf.Variable([0.0], name='bias')

# 修改变量
w.assign([2.0, 3.0])
print("权重:", w)

# 变量运算
result = w * 2 + b
print("运算结果:", result)

占位符（Placeholder）：

# 在 TensorFlow 2.x 中，推荐使用 tf.function
@tf.function
def model(x):
    w = tf.Variable([1.0, 2.0])
    b = tf.Variable([0.0])
    return tf.reduce_sum(x * w) + b

# 调用函数
input_data = tf.constant([3.0, 4.0])
output = model(input_data)
print("模型输出:", output)

3. 自动微分

TensorFlow 的自动微分功能让梯度计算变得简单：

# 定义函数
def f(x):
    return x**2 + 2*x + 1

# 计算梯度
x = tf.Variable(3.0)
with tf.GradientTape() as tape:
    y = f(x)

# 获取梯度
gradient = tape.gradient(y, x)
print("函数值:", y.numpy())
print("梯度值:", gradient.numpy())

# 验证：f'(x) = 2x + 2 = 2*3 + 2 = 8

模型构建与训练

1. 使用 Keras API 构建模型

顺序模型（Sequential）：

import tensorflow as tf
from tensorflow import keras

# 创建顺序模型
model = keras.Sequential([
    keras.layers.Dense(128, activation='relu', input_shape=(784,)),
    keras.layers.Dropout(0.2),
    keras.layers.Dense(64, activation='relu'),
    keras.layers.Dropout(0.2),
    keras.layers.Dense(10, activation='softmax')
])

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

函数式 API：

# 定义输入
inputs = keras.Input(shape=(784,))

# 定义层
x = keras.layers.Dense(128, activation='relu')(inputs)
x = keras.layers.Dropout(0.2)(x)
x = keras.layers.Dense(64, activation='relu')(x)
x = keras.layers.Dropout(0.2)(x)
outputs = keras.layers.Dense(10, activation='softmax')(x)

# 创建模型
model = keras.Model(inputs=inputs, outputs=outputs)

2. 模型编译与训练

编译模型：

# 配置优化器、损失函数和评估指标
model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

训练模型：

# 准备数据（以 MNIST 为例）
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# 数据预处理
x_train = x_train.reshape(60000, 784).astype('float32') / 255.0
x_test = x_test.reshape(10000, 784).astype('float32') / 255.0

# 训练模型
history = model.fit(
    x_train, y_train,
    batch_size=128,
    epochs=10,
    validation_data=(x_test, y_test),
    verbose=1
)

模型评估：

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

# 进行预测
predictions = model.predict(x_test[:5])
print("预测结果:", predictions)

3. 自定义模型

继承 Model 类：

class MyModel(keras.Model):
    def __init__(self):
        super(MyModel, self).__init__()
        self.dense1 = keras.layers.Dense(128, activation='relu')
        self.dropout1 = keras.layers.Dropout(0.2)
        self.dense2 = keras.layers.Dense(64, activation='relu')
        self.dropout2 = keras.layers.Dropout(0.2)
        self.dense3 = keras.layers.Dense(10, activation='softmax')

    def call(self, inputs, training=None):
        x = self.dense1(inputs)
        x = self.dropout1(x, training=training)
        x = self.dense2(x)
        x = self.dropout2(x, training=training)
        return self.dense3(x)

# 创建模型实例
model = MyModel()
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

高级特性

1. 分布式训练

多 GPU 训练：

# 配置多 GPU 策略
strategy = tf.distribute.MirroredStrategy()

with strategy.scope():
    # 在策略范围内创建模型
    model = keras.Sequential([
        keras.layers.Dense(128, activation='relu'),
        keras.layers.Dense(10, activation='softmax')
    ])

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

# 训练模型
model.fit(x_train, y_train, epochs=10, batch_size=64)

参数服务器训练：

# 配置参数服务器策略
cluster_resolver = tf.distribute.cluster_resolver.TFConfigClusterResolver()
strategy = tf.distribute.experimental.ParameterServerStrategy(cluster_resolver)

with strategy.scope():
    # 创建和训练模型
    pass

2. 混合精度训练

# 启用混合精度
policy = tf.keras.mixed_precision.Policy('mixed_float16')
tf.keras.mixed_precision.set_global_policy(policy)

# 创建模型（会自动使用混合精度）
model = keras.Sequential([
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dense(10, activation='softmax')
])

# 编译模型
model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

3. 模型保存与加载

保存模型：

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

# 保存模型权重
model.save_weights('my_weights')

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

# 保存模型架构
model_json = model.to_json()
with open('model_architecture.json', 'w') as f:
    f.write(model_json)

加载模型：

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

# 加载模型权重
new_model = keras.Sequential([...])  # 先创建相同架构的模型
new_model.load_weights('my_weights')

# 从 JSON 加载架构
with open('model_architecture.json', 'r') as f:
    model_json = f.read()
loaded_model = keras.models.model_from_json(model_json)

实际应用案例

1. 图像分类

使用预训练模型：

import tensorflow as tf
from tensorflow import keras

# 加载预训练的 ResNet50 模型
base_model = keras.applications.ResNet50(
    weights='imagenet',
    include_top=False,
    input_shape=(224, 224, 3)
)

# 冻结预训练层
base_model.trainable = False

# 添加自定义分类层
model = keras.Sequential([
    base_model,
    keras.layers.GlobalAveragePooling2D(),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dropout(0.2),
    keras.layers.Dense(10, activation='softmax')
])

# 编译模型
model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=0.001),
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

数据增强：

# 创建数据增强器
data_augmentation = keras.Sequential([
    keras.layers.RandomFlip('horizontal'),
    keras.layers.RandomRotation(0.1),
    keras.layers.RandomZoom(0.1),
    keras.layers.RandomContrast(0.1)
])

# 在模型中应用数据增强
model = keras.Sequential([
    data_augmentation,
    base_model,
    keras.layers.GlobalAveragePooling2D(),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dropout(0.2),
    keras.layers.Dense(10, activation='softmax')
])

2. 目标检测

使用 TensorFlow Object Detection API：

import tensorflow as tf
from object_detection.utils import config_util
from object_detection.builders import model_builder

# 加载配置文件
config = config_util.get_configs_from_pipeline_file('ssd_mobilenet_v2_coco.config')

# 创建模型
model = model_builder.build(model_config=config['model'], is_training=True)

# 编译模型
model.compile(optimizer='adam', loss='mse')

# 训练模型
model.fit(train_dataset, epochs=10, validation_data=val_dataset)

3. 自然语言处理

文本分类：

import tensorflow as tf
from tensorflow import keras

# 文本预处理
tokenizer = keras.preprocessing.text.Tokenizer(num_words=10000)
tokenizer.fit_on_texts(texts)
sequences = tokenizer.texts_to_sequences(texts)
padded_sequences = keras.preprocessing.sequence.pad_sequences(sequences, maxlen=100)

# 创建模型
model = keras.Sequential([
    keras.layers.Embedding(10000, 128, input_length=100),
    keras.layers.LSTM(64, return_sequences=True),
    keras.layers.LSTM(32),
    keras.layers.Dense(64, activation='relu'),
    keras.layers.Dropout(0.2),
    keras.layers.Dense(1, activation='sigmoid')
])

# 编译和训练
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
model.fit(padded_sequences, labels, epochs=10, validation_split=0.2)

性能优化

1. 图优化

使用 tf.function 装饰器：

@tf.function
def train_step(x, y):
    with tf.GradientTape() as tape:
        predictions = model(x)
        loss = loss_fn(y, predictions)

    gradients = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(gradients, model.trainable_variables))
    return loss

# 训练循环
for epoch in range(num_epochs):
    for batch_x, batch_y in train_dataset:
        loss = train_step(batch_x, batch_y)

XLA 编译优化：

# 启用 XLA 编译
@tf.function(jit_compile=True)
def optimized_function(x):
    return tf.nn.relu(tf.matmul(x, weights) + bias)

2. 内存优化

使用 tf.data 优化数据管道：

# 创建高效的数据管道
def create_dataset(images, labels, batch_size=32):
    dataset = tf.data.Dataset.from_tensor_slices((images, labels))
    dataset = dataset.shuffle(buffer_size=1000)
    dataset = dataset.batch(batch_size)
    dataset = dataset.prefetch(tf.data.AUTOTUNE)
    return dataset

# 使用数据管道
train_dataset = create_dataset(x_train, y_train, batch_size=64)
val_dataset = create_dataset(x_val, y_val, batch_size=64)

内存映射：

# 使用内存映射读取大文件
def read_large_file(filename):
    return tf.data.TextLineDataset(filename).map(parse_function)

3. 模型优化

模型剪枝：

import tensorflow_model_optimization as tfmot

# 创建剪枝配置
pruning_params = {
    'pruning_schedule': tfmot.sparsity.keras.PolynomialDecay(
        initial_sparsity=0.0,
        final_sparsity=0.5,
        begin_step=0,
        end_step=1000
    )
}

# 应用剪枝
model = tfmot.sparsity.keras.prune_low_magnitude(model, **pruning_params)

# 编译和训练
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(x_train, y_train, epochs=10)

量化：

# 训练后量化
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
quantized_model = converter.convert()

# 量化感知训练
quantize_model = tfmot.quantization.keras.quantize_model(model)
quantize_model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

部署与生产

1. TensorFlow Serving

创建 SavedModel：

# 保存模型为 SavedModel 格式
model.save('saved_model/my_model', save_format='tf')

# 或使用 tf.saved_model.save
tf.saved_model.save(model, 'saved_model/my_model')

启动 TensorFlow Serving：

# 使用 Docker 启动服务
docker run -p 8501:8501 \
  --mount type=bind,source=/path/to/saved_model,target=/models/my_model \
  -e MODEL_NAME=my_model \
  -t tensorflow/serving

客户端调用：

import requests
import json

# 准备数据
data = {
    "instances": [[1, 2, 3, 4, 5]]
}

# 发送请求
response = requests.post(
    'http://localhost:8501/v1/models/my_model:predict',
    data=json.dumps(data)
)

# 获取预测结果
predictions = response.json()['predictions']
print("预测结果:", predictions)

2. TensorFlow Lite

模型转换：

# 转换为 TensorFlow Lite 格式
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()

# 保存模型
with open('model.tflite', 'wb') as f:
    f.write(tflite_model)

移动端推理：

# Python 端测试
interpreter = tf.lite.Interpreter(model_path='model.tflite')
interpreter.allocate_tensors()

# 获取输入输出张量
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

# 准备输入数据
input_data = np.array([[1, 2, 3, 4, 5]], dtype=np.float32)
interpreter.set_tensor(input_details[0]['index'], input_data)

# 执行推理
interpreter.invoke()

# 获取输出
output_data = interpreter.get_tensor(output_details[0]['index'])
print("预测结果:", output_data)

3. TensorFlow.js

模型转换：

# 安装转换工具
pip install tensorflowjs

# 转换模型
tensorflowjs_converter \
  --input_format=keras \
  --output_format=tfjs_layers_model \
  my_model.h5 \
  web_model/

Web 端使用：

// 加载模型
const model = await tf.loadLayersModel("web_model/model.json");

// 准备输入数据
const input = tf.tensor2d([[1, 2, 3, 4, 5]], [1, 5]);

// 进行预测
const prediction = model.predict(input);
const result = await prediction.data();

console.log("预测结果:", result);

调试与监控

1. TensorBoard 可视化

记录训练过程：

# 创建回调函数
tensorboard_callback = keras.callbacks.TensorBoard(
    log_dir='./logs',
    histogram_freq=1,
    write_graph=True,
    write_images=True
)

# 训练时使用回调
model.fit(
    x_train, y_train,
    epochs=10,
    validation_data=(x_test, y_test),
    callbacks=[tensorboard_callback]
)

启动 TensorBoard：

# 启动 TensorBoard 服务
tensorboard --logdir=./logs --port=6006

查看可视化：

打开浏览器访问 http://localhost:6006
查看训练损失和准确率曲线
分析模型结构和参数分布
监控梯度变化和权重更新

2. 模型分析

模型结构分析：

# 查看模型摘要
model.summary()

# 获取模型参数数量
total_params = model.count_params()
print(f"总参数数量: {total_params:,}")

# 分析每层参数
for layer in model.layers:
    params = layer.count_params()
    print(f"{layer.name}: {params:,} 参数")

性能分析：

# 使用 tf.profiler 分析性能
with tf.profiler.experimental.Profile('logdir'):
    # 运行需要分析的代码
    model.fit(x_train, y_train, epochs=1)

3. 错误调试

常见错误类型：

形状不匹配错误
数据类型错误
设备放置错误
内存不足错误

调试技巧：

# 启用 eager execution 进行调试
tf.config.run_functions_eagerly(True)

# 使用 tf.debugging 检查张量
tf.debugging.check_numerics(tensor, message="检查数值")

# 使用 tf.print 打印中间结果
tf.print("张量值:", tensor)

# 使用 tf.assert 进行断言
tf.assert_equal(tf.shape(tensor)[0], batch_size, message="批次大小不匹配")

最佳实践

1. 代码组织

项目结构：

my_tensorflow_project/
├── data/
│   ├── raw/
│   ├── processed/
│   └── external/
├── models/
│   ├── __init__.py
│   ├── base_model.py
│   └── custom_layers.py
├── training/
│   ├── __init__.py
│   ├── train.py
│   └── evaluate.py
├── utils/
│   ├── __init__.py
│   ├── data_utils.py
│   └── visualization.py
├── configs/
│   └── config.yaml
├── notebooks/
│   └── exploration.ipynb
└── requirements.txt

配置管理：

# config.py
import yaml

class Config:
    def __init__(self, config_path):
        with open(config_path, 'r') as f:
            self.config = yaml.safe_load(f)

    def get(self, key, default=None):
        return self.config.get(key, default)

# 使用配置
config = Config('configs/config.yaml')
learning_rate = config.get('learning_rate', 0.001)
batch_size = config.get('batch_size', 32)

2. 数据处理

高效的数据管道：

def create_efficient_dataset(file_pattern, batch_size=32, shuffle=True):
    """创建高效的数据管道"""
    dataset = tf.data.Dataset.list_files(file_pattern)
    dataset = dataset.interleave(
        lambda x: tf.data.TFRecordDataset(x),
        num_parallel_calls=tf.data.AUTOTUNE
    )

    if shuffle:
        dataset = dataset.shuffle(buffer_size=1000)

    dataset = dataset.batch(batch_size)
    dataset = dataset.prefetch(tf.data.AUTOTUNE)

    return dataset

数据验证：

def validate_data(x, y):
    """验证数据格式和范围"""
    assert x.shape[0] == y.shape[0], "样本数量不匹配"
    assert x.dtype == tf.float32, "输入数据类型错误"
    assert y.dtype == tf.int32, "标签数据类型错误"

    # 检查数值范围
    tf.debugging.assert_all_finite(x, "输入包含无效数值")
    tf.debugging.assert_non_negative(y, "标签不能为负数")

3. 模型设计

模块化设计：

class ResidualBlock(keras.layers.Layer):
    def __init__(self, filters, kernel_size=3, **kwargs):
        super(ResidualBlock, self).__init__(**kwargs)
        self.filters = filters
        self.kernel_size = kernel_size

        self.conv1 = keras.layers.Conv2D(filters, kernel_size, padding='same')
        self.bn1 = keras.layers.BatchNormalization()
        self.conv2 = keras.layers.Conv2D(filters, kernel_size, padding='same')
        self.bn2 = keras.layers.BatchNormalization()
        self.add = keras.layers.Add()
        self.activation = keras.layers.Activation('relu')

    def call(self, inputs, training=None):
        x = self.conv1(inputs)
        x = self.bn1(x, training=training)
        x = self.activation(x)

        x = self.conv2(x)
        x = self.bn2(x, training=training)

        # 残差连接
        if inputs.shape[-1] != self.filters:
            # 需要调整输入维度
            inputs = keras.layers.Conv2D(self.filters, 1)(inputs)

        x = self.add([x, inputs])
        return self.activation(x)

超参数调优：

import keras_tuner as kt

def build_model(hp):
    model = keras.Sequential()

    # 可调超参数
    hp_units = hp.Int('units', min_value=32, max_value=512, step=32)
    hp_layers = hp.Int('layers', min_value=1, max_value=5)
    hp_learning_rate = hp.Choice('learning_rate', values=[1e-2, 1e-3, 1e-4])

    # 构建模型
    for i in range(hp_layers):
        model.add(keras.layers.Dense(units=hp_units, activation='relu'))
        model.add(keras.layers.Dropout(0.2))

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

    model.compile(
        optimizer=keras.optimizers.Adam(learning_rate=hp_learning_rate),
        loss='sparse_categorical_crossentropy',
        metrics=['accuracy']
    )

    return model

# 创建调优器
tuner = kt.Hyperband(
    build_model,
    objective='val_accuracy',
    max_epochs=10,
    factor=3,
    directory='my_dir',
    project_name='intro_to_kt'
)

# 开始搜索
tuner.search(x_train, y_train, epochs=5, validation_data=(x_val, y_val))

常见问题与解决方案

1. 内存问题

问题： GPU 内存不足

解决方案：

# 设置 GPU 内存增长
gpus = tf.config.experimental.list_physical_devices('GPU')
if gpus:
    try:
        for gpu in gpus:
            tf.config.experimental.set_memory_growth(gpu, True)
    except RuntimeError as e:
        print(e)

# 减少批次大小
batch_size = 16  # 从 32 减少到 16

# 使用混合精度
tf.keras.mixed_precision.set_global_policy('mixed_float16')

2. 训练不稳定

问题： 损失震荡或梯度爆炸

解决方案：

# 梯度裁剪
optimizer = keras.optimizers.Adam(clipnorm=1.0)

# 学习率调度
lr_schedule = keras.optimizers.schedules.ExponentialDecay(
    initial_learning_rate=1e-3,
    decay_steps=1000,
    decay_rate=0.9
)
optimizer = keras.optimizers.Adam(learning_rate=lr_schedule)

# 批标准化
model.add(keras.layers.BatchNormalization())

3. 过拟合问题

问题： 训练准确率高但验证准确率低

解决方案：

# 添加正则化
model.add(keras.layers.Dropout(0.5))
model.add(keras.layers.Dense(64, kernel_regularizer=keras.regularizers.l2(0.01)))

# 早停
early_stopping = keras.callbacks.EarlyStopping(
    monitor='val_loss',
    patience=5,
    restore_best_weights=True
)

# 数据增强
data_augmentation = keras.Sequential([
    keras.layers.RandomFlip('horizontal'),
    keras.layers.RandomRotation(0.1),
    keras.layers.RandomZoom(0.1)
])

4. 模型转换问题

问题： 模型无法转换为 TensorFlow Lite

解决方案：

# 检查不支持的操作
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.allow_custom_ops = True

# 使用量化
converter.optimizations = [tf.lite.Optimize.DEFAULT]

# 设置输入输出形状
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS]