「日拱一码」017 深度学习常用库——TensorFlow

发布于：2025-07-06 ⋅ 阅读:(23) ⋅ 点赞:(0)

目录

基础操作

张量操作：

tf.constant 用于创建常量张量

tf.Variable 用于创建可训练的变量张量

tf.reshape 可改变张量的形状

tf.concat 可将多个张量沿指定维度拼接

tf.split 则可将张量沿指定维度分割

数学运算：

tf.add 张量的加运算

tf.subtract 张量的减运算

tf.multiply 张量的乘运算

tf.divide 张量的除运算

tf.pow 计算张量的幂

tf.sqrt 计算张量的平方根

tf.reduce_sum 在指定维度上对张量进行求和

tf.reduce_mean 在指定维度上对张量进行求平均值

tf.reduce_max 在指定维度上对张量进行求最大值

逻辑运算：

tf.equal 比较两个张量的是否相等

tf.not_equal  比较两个张量的是否不相等

tf.less 逐元素比较两个张量，前者是否小于后者

tf.greater 逐元素比较两个张量，前者是否大于后者

tf.logical_and 逻辑与运算

tf.logical_or 逻辑或运算

tf.logical_not 逻辑非运算

神经网络构建

层操作：

tf.keras.layers.Dense 用于创建全连接层

tf.keras.layers.Conv2D 用于创建二维卷积层

tf.keras.layers.MaxPooling2D 用于创建二维最大池化层

tf.keras.layers.Flatten 用于将多维张量展平为一维张量

tf.keras.layers.Dropout 用于在训练过程中随机丢弃部分神经元，以防止过拟合

模型构建：

tf.keras.Sequential 用于构建顺序模型，通过将各层按顺序堆叠起来

tf.keras.Model 则提供了更灵活的模型构建方式，允许用户自定义模型的输入、输出和前向传播过程

激活函数：

tf.nn.relu 是常用的激活函数，可将输入张量中的负值置为0

tf.nn.sigmoid 将输入映射到(0,1)区间

tf.nn.tanh 将输入映射到(-1,1)区间

 tf.nn.softmax 常用于多分类问题的输出层，可将输入映射到概率分布上

损失函数：

tf.keras.losses.MeanSquaredError 用于回归问题，计算预测值与真实值之间的均方误差

tf.keras.losses.SparseCategoricalCrossentropy 用于多分类问题中的整数标签

tf.keras.losses.CategoricalCrossentropy 用于多分类问题中的独热编码标签

tf.keras.losses.BinaryCrossentropy 用于二分类问题

优化器：

tf.keras.optimizers.SGD 是随机梯度下降优化器

tf.keras.optimizers.Adam 是自适应矩估计优化器

tf.keras.optimizers.RMSprop 是均方根传播优化器

tf.keras.optimizers.Adagrad 是自适应梯度优化器

 数据处理

数据加载：

tf.data.Dataset.from_tensor_slices 从张量等数据源创建数据集对象

tf.data.Dataset.from_generator 等方法从生成器等数据源创建数据集对象

tf.data.TFRecordDataset 用于读取TFRecord格式的数据文件

数据预处理：

tf.data.Dataset.map 可对数据集中的每个元素进行数据预处理操作，如归一化、标准化、数据增强等

tf.data.Dataset.batch 用于将数据集中的元素分批

tf.data.Dataset.shuffle 用于对数据集中的元素进行随机打乱

特征列：

tf.feature_column.numeric_column 用于定义数值型特征列

tf.feature_column.categorical_column_with_vocabulary_list 用于定义分类型特征列

tf.feature_column.embedding_column 用于定义嵌入特征列等，这些特征列可用于将原始数据转换为模型可接受的输入格式

模型训练与评估

模型训练：

model.fit 方法用于训练模型，可指定训练数据、验证数据、训练轮数、批大小等参数

model.train_on_batch 方法可用于对单个批次的数据进行训练

model.evaluate 方法用于评估模型在测试数据上的性能，返回损失值和指标值

回调函数：

tf.keras.callbacks.ModelCheckpoint 用于在训练过程中保存模型的权重

tf.keras.callbacks.EarlyStopping 用于在验证集性能不再提升时提前停止训练

tf.keras.callbacks.TensorBoard 用于将训练过程中的日志保存到TensorBoard中，方便可视化

模型保存与加载：

model.save 方法可将整个模型保存为一个文件，包括模型的结构、权重和优化器等信息

tf.keras.models.load_model 方法用于加载保存的模型文件

model.save_weights 方法用于仅保存模型的权重

model.load_weights 方法用于仅加载模型的权重

高级功能

分布式训练：

tf.distribute.MirroredStrategy 用于单机多GPU训练

tf.distribute.MultiWorkerMirroredStrategy 用于多机多GPU训练等，可实现模型在多个设备上的并行训练，提高训练效率

自定义操作：

tf.raw_ops 访问底层的原生操作

tf.py_function 将Python函数包装为TensorFlow操作，实现自定义的计算逻辑

自动微分：

tf.GradientTape 提供了自动微分的功能，可记录张量的运算过程，并在需要时计算梯度，为自定义模型和优化算法提供了便利

模型部署

tf.saved_model 模块用于将模型保存为SavedModel格式，方便在不同的平台上进行部署和推理

tf.lite.TFLiteConverter 用于将TensorFlow模型转换为TensorFlow Lite模型，以便在移动设备和边缘设备上运行

可视化工具

TensorBoard：TensorBoard是TensorFlow自带的可视化工具，可通过 tf.summary 模块将训练过程中的日志写入到日志文件中，然后使用TensorBoard读取日志文件，可视化模型的结构、训练过程中的损失值和指标值、权重和梯度的变化等信息，帮助用户更好地了解模型的训练情况和性能表现

其他功能

音频处理：

tf.audio.decode_wav 用于解码WAV格式的音频文件

tf.audio.encode_wav 用于编码WAV格式的音频文件

tf.audio.spectrogram 用于计算音频信号的频谱图等

文本处理：

tf.text.BertTokenizer 用于对文本进行BERT分词

tf.text.UnicodeScriptTokenizer 用于根据Unicode脚本对文本进行分词

图像处理：

tf.image.resize 用于调整图像的大小

tf.image.random_crop 用于随机裁剪图像

tf.image.rgb_to_grayscale 用于将RGB图像转换为灰度图像

TensorFlow是一个开源的机器学习框架，广泛应用于深度学习领域。以下是TensorFlow库中各种方法功能的分类介绍：

基础操作

张量操作：

  • tf.constant 用于创建常量张量
  • tf.Variable 用于创建可训练的变量张量
  • tf.reshape 可改变张量的形状
  • tf.concat 可将多个张量沿指定维度拼接
  • tf.split 则可将张量沿指定维度分割
## 基础操作
# 张量操作

import tensorflow as tf

# 创建常量张量
constant_tensor = tf.constant([[1, 2], [3, 4]], dtype=tf.float32)
print(constant_tensor)
# tf.Tensor(
# [[1. 2.]
#  [3. 4.]], shape=(2, 2), dtype=float32)

# 创建可训练的变量张量
variable_tensor = tf.Variable([[5, 6], [7, 8]], dtype=tf.float32)
print(variable_tensor)
# <tf.Variable 'Variable:0' shape=(2, 2) dtype=float32, numpy=
# array([[5., 6.],
#        [7., 8.]], dtype=float32)>

# 改变张量的形状
reshaped_tensor = tf.reshape(constant_tensor, [1, 4])  # 将2x2张量重塑为1x4张量
print(reshaped_tensor)  # tf.Tensor([[1. 2. 3. 4.]], shape=(1, 4), dtype=float32)

# 沿指定维度拼接张量
concatenated_tensor = tf.concat([constant_tensor, variable_tensor], axis=0)  # 沿第0维拼接
print(concatenated_tensor)
# tf.Tensor(
# [[1. 2.]
#  [3. 4.]
#  [5. 6.]
#  [7. 8.]], shape=(4, 2), dtype=float32)

# 沿指定维度分割张量
split_tensors = tf.split(concatenated_tensor, num_or_size_splits=2, axis=0)  # 沿第0维分割为2个张量
print(split_tensors)

# [<tf.Tensor: shape=(2, 2), dtype=float32, numpy=
# array([[1., 2.],
#        [3., 4.]], dtype=float32)>, <tf.Tensor: shape=(2, 2), dtype=float32, numpy=
# array([[5., 6.],
#        [7., 8.]], dtype=float32)>]

数学运算：

  • tf.add 张量的加运算
  • tf.subtract 张量的减运算
  • tf.multiply 张量的乘运算
  • tf.divide 张量的除运算
  • tf.pow 计算张量的幂
  • tf.sqrt 计算张量的平方根
  • tf.reduce_sum 在指定维度上对张量进行求和
  • tf.reduce_mean 在指定维度上对张量进行求平均值
  • tf.reduce_max 在指定维度上对张量进行求最大值
# 数学运算
import tensorflow as tf

# 张量加法
add_result = tf.add(constant_tensor, variable_tensor)
print("加法结果：", add_result)
# tf.Tensor(
# [[ 6.  8.]
#  [10. 12.]], shape=(2, 2), dtype=float32)

# 张量乘法
multiply_result = tf.multiply(constant_tensor, variable_tensor)
print("乘法结果：", multiply_result)
# tf.Tensor(
# [[ 5. 12.]
#  [21. 32.]], shape=(2, 2), dtype=float32)

# 计算张量的平方根
sqrt_result = tf.sqrt(constant_tensor)
print("平方根结果：", sqrt_result)
# tf.Tensor(
# [[1.        1.4142135]
#  [1.7320508 2.       ]], shape=(2, 2), dtype=float32)

# 在指定维度上求和
sum_result = tf.reduce_sum(constant_tensor, axis=1)  # 沿第1维求和
print("求和结果：", sum_result)  # tf.Tensor([3. 7.], shape=(2,), dtype=float32)

逻辑运算：

  • tf.equal 比较两个张量的是否相等
  • tf.not_equal  比较两个张量的是否不相等
  • tf.less 逐元素比较两个张量，前者是否小于后者
  • tf.greater 逐元素比较两个张量，前者是否大于后者
  • tf.logical_and 逻辑与运算
  • tf.logical_or 逻辑或运算
  • tf.logical_not 逻辑非运算
# 逻辑运算
import tensorflow as tf

# 比较两个张量的大小关系
comparison_result = tf.less(constant_tensor, variable_tensor)  # 比较元素是否小于
print("比较结果：", comparison_result)
# tf.Tensor(
# [[ True  True]
#  [ True  True]], shape=(2, 2), dtype=bool)

# 逻辑与运算
logical_and_result = tf.logical_and(comparison_result, comparison_result)
print("逻辑与结果：", logical_and_result)
# tf.Tensor(
# [[ True  True]
#  [ True  True]], shape=(2, 2), dtype=bool)

logical_not_result = tf.logical_not(comparison_result, comparison_result)
print("逻辑非结果：", logical_not_result)
# tf.Tensor(
# [[False False]
#  [False False]], shape=(2, 2), dtype=bool)

神经网络构建

层操作：

  • tf.keras.layers.Dense 用于创建全连接层
  • tf.keras.layers.Conv2D 用于创建二维卷积层
  • tf.keras.layers.MaxPooling2D 用于创建二维最大池化层
  • tf.keras.layers.Flatten 用于将多维张量展平为一维张量
  • tf.keras.layers.Dropout 用于在训练过程中随机丢弃部分神经元，以防止过拟合
## 神经网络构建
# 层操作

import tensorflow as tf

# 创建全连接层
dense_layer = tf.keras.layers.Dense(units=10, activation='relu', input_shape=(5,))
print("全连接层：", dense_layer)  # <keras.layers.core.dense.Dense object at 0x00000219CD853D30>

# 创建二维卷积层
conv2d_layer = tf.keras.layers.Conv2D(filters=32, kernel_size=(3, 3), activation='relu', input_shape=(28, 28, 1))
print("二维卷积层：", conv2d_layer)  # <keras.layers.convolutional.Conv2D object at 0x00000219CD8EE040>

# 创建二维最大池化层
max_pooling_layer = tf.keras.layers.MaxPooling2D(pool_size=(2, 2))
print("二维最大池化层：", max_pooling_layer)  # <keras.layers.pooling.MaxPooling2D object at 0x00000219CD853E50>

模型构建：

  • tf.keras.Sequential 用于构建顺序模型，通过将各层按顺序堆叠起来
  • tf.keras.Model 则提供了更灵活的模型构建方式，允许用户自定义模型的输入、输出和前向传播过程
# 模型构建

# 构建顺序模型
model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dense(32, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')
])
model.summary()  # 打印模型结构
# Model: "sequential"
# _________________________________________________________________
# Layer(type)         Output  Shape           Param  #
# == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == =
# dense_1(Dense)        (None, 64)            50240
#
# dense_2(Dense)        (None, 32)            2080
#
# dense_3(Dense)        (None, 10)            330
#
# == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == =
# Total params: 52, 650
# Trainable params: 52, 650
# Non - trainable params: 0
# _________________________________________________________________





# 使用自定义模型
class MyModel(tf.keras.Model):
    def __init__(self):
        super(MyModel, self).__init__()
        self.dense1 = tf.keras.layers.Dense(64, activation='relu')
        self.dense2 = tf.keras.layers.Dense(32, activation='relu')
        self.dense3 = tf.keras.layers.Dense(10, activation='softmax')

    def call(self, inputs):
        x = self.dense1(inputs)
        x = self.dense2(x)
        return self.dense3(x)

custom_model = MyModel()
custom_model.build(input_shape=(None, 784))
custom_model.summary()
# Model: "my_model"
# _________________________________________________________________
# Layer(type)         Output  Shape            Param  #
# == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == =
# dense_4(Dense)        multiple               50240
# dense_5(Dense)        multiple               2080
# dense_6(Dense)        multiple                330
# == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == =
# Total params: 52, 650
# Trainable params: 52, 650
# Non - trainable params: 0
# _________________________________________________________________

激活函数：

  • tf.nn.relu 是常用的激活函数，可将输入张量中的负值置为0
  • tf.nn.sigmoid 将输入映射到(0,1)区间
  • tf.nn.tanh 将输入映射到(-1,1)区间
  •  tf.nn.softmax 常用于多分类问题的输出层，可将输入映射到概率分布上
# 激活函数
# 使用ReLU激活函数
relu_activation = tf.nn.relu(constant_tensor)
print("ReLU激活结果：", relu_activation)
# tf.Tensor(
# [[1. 2.]
#  [3. 4.]], shape=(2, 2), dtype=float32)

# 使用Sigmoid激活函数
sigmoid_activation = tf.nn.sigmoid(constant_tensor)
print("Sigmoid激活结果：", sigmoid_activation)
# tf.Tensor(
# [[0.7310586  0.8807971 ]
#  [0.95257413 0.98201376]], shape=(2, 2), dtype=float32)

损失函数：

  • tf.keras.losses.MeanSquaredError 用于回归问题，计算预测值与真实值之间的均方误差
  • tf.keras.losses.SparseCategoricalCrossentropy 用于多分类问题中的整数标签
  • tf.keras.losses.CategoricalCrossentropy 用于多分类问题中的独热编码标签
  • tf.keras.losses.BinaryCrossentropy 用于二分类问题
# 损失函数
# 创建真实标签和预测值
true_labels = tf.constant([0, 1, 2, 3], dtype=tf.int32)
predicted_logits = tf.constant([[0.1, 0.2, 0.3, 0.4], [0.4, 0.3, 0.2, 0.1], [0.2, 0.3, 0.4, 0.1], [0.3, 0.2, 0.1, 0.4]], dtype=tf.float32)

# 计算稀疏分类交叉熵损失
sparse_loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)(true_labels, predicted_logits)
print("稀疏分类交叉熵损失：", sparse_loss)  # tf.Tensor(1.3425356, shape=(), dtype=float32)

优化器：

  • tf.keras.optimizers.SGD 是随机梯度下降优化器
  • tf.keras.optimizers.Adam 是自适应矩估计优化器
  • tf.keras.optimizers.RMSprop 是均方根传播优化器
  • tf.keras.optimizers.Adagrad 是自适应梯度优化器
# 优化器
# 创建优化器
optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)

# 创建变量和梯度
variable = tf.Variable([1.0, 2.0])
with tf.GradientTape() as tape:
    loss = tf.reduce_sum(variable ** 2)

# 计算梯度
gradients = tape.gradient(loss, variable)
print("梯度：", gradients)  # tf.Tensor([2. 4.], shape=(2,), dtype=float32)

# 应用梯度更新变量
optimizer.apply_gradients(zip([gradients], [variable]))
print("更新后的变量：", variable)  # <tf.Variable 'Variable:0' shape=(2,) dtype=float32, numpy=array([0.999, 1.999], dtype=float32)>

 数据处理

数据加载：

  • tf.data.Dataset.from_tensor_slices 从张量等数据源创建数据集对象
  • tf.data.Dataset.from_generator 等方法从生成器等数据源创建数据集对象
  • tf.data.TFRecordDataset 用于读取TFRecord格式的数据文件
## 数据处理

# 数据加载
import tensorflow as tf

# 创建两个张量，分别作为特征和标签
features = tf.constant([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]])
labels = tf.constant([0, 1, 0])

# 从张量创建数据集
tensor_slices_dataset = tf.data.Dataset.from_tensor_slices((features, labels))

# 打印数据集中的每个元素
for feature, label in tensor_slices_dataset:
    print("特征：", feature.numpy(), "标签：", label.numpy())
    # 特征： [1. 2.]   标签： 0
    # 特征： [3. 4.]   标签： 1
    # 特征： [5. 6.]   标签： 0





# 从生成器创建数据集
# 定义一个生成器函数
def generator():
    for i in range(3):
        yield (tf.constant([i, i + 1], dtype=tf.float32), tf.constant(i % 2, dtype=tf.int32))

# 从生成器创建数据集
generator_dataset = tf.data.Dataset.from_generator(
    generator,
    output_signature=(tf.TensorSpec(shape=(2,), dtype=tf.float32), tf.TensorSpec(shape=(), dtype=tf.int32))
)

# 打印数据集中的每个元素
for feature, label in generator_dataset:
    print("特征：", feature.numpy(), "标签：", label.numpy())
    # 特征： [0. 1.]   标签： 0
    # 特征： [1. 2.]   标签： 1
    # 特征： [2. 3.]   标签： 0

数据预处理：

  • tf.data.Dataset.map 可对数据集中的每个元素进行数据预处理操作，如归一化、标准化、数据增强等
  • tf.data.Dataset.batch 用于将数据集中的元素分批
  • tf.data.Dataset.shuffle 用于对数据集中的元素进行随机打乱
# 数据预处理

# 对数据集中的每个元素应用函数进行预处理
# 定义一个预处理函数，将特征值加1，标签值乘以2
def preprocess(feature, label):
    return feature + 1, label * 2

# 对数据集中的每个元素应用预处理函数
preprocessed_dataset = tensor_slices_dataset.map(preprocess)

# 打印预处理后的数据集中的每个元素
for feature, label in preprocessed_dataset:
    print("预处理后的特征：", feature.numpy(), "预处理后的标签：", label.numpy())
    # 预处理后的特征： [2. 3.]    预处理后的标签： 0
    # 预处理后的特征： [4. 5.]    预处理后的标签： 2
    # 预处理后的特征： [6. 7.]    预处理后的标签： 0




# 将数据集中的元素分批，每批包含2个元素
batched_dataset = preprocessed_dataset.batch(batch_size=2)

# 打印分批后的数据集中的每个批次
for batch in batched_dataset:
    print("批次特征：", batch[0].numpy(), "批次标签：", batch[1].numpy())
    # 批次特征： [[2. 3.]
    #            [4. 5.]] 批次标签： [0 2]
    # 批次特征： [[6. 7.]]  批次标签： [0]





# 对数据集中的元素进行随机打乱，缓冲区大小为10
shuffled_dataset = batched_dataset.shuffle(buffer_size=10)

# 打印随机打乱后的数据集中的每个批次
for batch in shuffled_dataset:
    print("随机打乱后的批次特征：", batch[0].numpy(), "随机打乱后的批次标签：", batch[1].numpy())
    # 随机打乱后的批次特征： [[2. 3.]
    #                    [4. 5.]] 随机打乱后的批次标签： [0 2]
    # 随机打乱后的批次特征： [[6. 7.]] 随机打乱后的批次标签： [0]

特征列：

  • tf.feature_column.numeric_column 用于定义数值型特征列
  • tf.feature_column.categorical_column_with_vocabulary_list 用于定义分类型特征列
  • tf.feature_column.embedding_column 用于定义嵌入特征列等，这些特征列可用于将原始数据转换为模型可接受的输入格式
# 特征列
# 定义一个数值型特征列，表示年龄
numeric_feature_column = tf.feature_column.numeric_column('age')

# 打印数值型特征列
print("数值型特征列：", numeric_feature_column) # NumericColumn(key='age', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None)




# 定义一个分类型特征列，表示性别，词汇表为['male', 'female']
categorical_feature_column = tf.feature_column.categorical_column_with_vocabulary_list(
    'gender', vocabulary_list=['male', 'female']
)

# 打印分类型特征列
print("分类型特征列：", categorical_feature_column) # VocabularyListCategoricalColumn(key='gender', vocabulary_list=('male', 'female'), dtype=tf.string, default_value=-1, num_oov_buckets=0)





# 定义一个嵌入特征列，基于分类型特征列，嵌入维度为2
embedding_feature_column = tf.feature_column.embedding_column(categorical_feature_column, dimension=2)

# 打印嵌入特征列
print("嵌入特征列：", embedding_feature_column) # EmbeddingColumn(categorical_column=VocabularyListCategoricalColumn(key='gender', vocabulary_list=('male', 'female'), dtype=tf.string, default_value=-1, num_oov_buckets=0), dimension=2, combiner='mean', initializer=<tensorflow.python.ops.init_ops.TruncatedNormal object at 0x00000242F3C93A00>, ckpt_to_load_from=None, tensor_name_in_ckpt=None, max_norm=None, trainable=True, use_safe_embedding_lookup=True)

模型训练与评估

模型训练：

  • model.fit 方法用于训练模型，可指定训练数据、验证数据、训练轮数、批大小等参数
  • model.train_on_batch 方法可用于对单个批次的数据进行训练
  • model.evaluate 方法用于评估模型在测试数据上的性能，返回损失值和指标值
## 模型训练与评估

# 模型训练
# 创建模型
model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dense(32, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')
])

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


# 创建虚拟数据
import numpy as np
x_train = np.random.random((100, 784))
y_train = np.random.randint(10, size=(100,))
x_val = np.random.random((20, 784))
y_val = np.random.randint(10, size=(20,))

# 训练模型
history = model.fit(x_train, y_train, epochs=5, batch_size=10, validation_data=(x_val, y_val))
print("训练历史：", history.history)
# {'loss': [2.363245964050293, 2.2334864139556885, 2.156087636947632, 2.062870979309082, 1.9401884078979492],
#  'accuracy': [0.12999999523162842, 0.1599999964237213, 0.18000000715255737, 0.2199999988079071, 0.4000000059604645],
#  'val_loss': [2.2029895782470703, 2.1940360069274902, 2.263622283935547, 2.2735862731933594, 2.2560040950775146],
#  'val_accuracy': [0.10000000149011612, 0.30000001192092896, 0.15000000596046448, 0.10000000149011612,
#                   0.15000000596046448]}

回调函数：

  • tf.keras.callbacks.ModelCheckpoint 用于在训练过程中保存模型的权重
  • tf.keras.callbacks.EarlyStopping 用于在验证集性能不再提升时提前停止训练
  • tf.keras.callbacks.TensorBoard 用于将训练过程中的日志保存到TensorBoard中，方便可视化
# 回调函数

# 创建回调函数
checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(filepath='model.{epoch:02d}-{val_loss:.2f}.h5', save_best_only=True)
early_stopping_callback = tf.keras.callbacks.EarlyStopping(patience=2, monitor='val_loss')

# 使用回调函数训练模型
model.fit(x_train, y_train, epochs=10, batch_size=10, validation_data=(x_val, y_val), callbacks=[checkpoint_callback, early_stopping_callback])

模型保存与加载：

  • model.save 方法可将整个模型保存为一个文件，包括模型的结构、权重和优化器等信息
  • tf.keras.models.load_model 方法用于加载保存的模型文件
  • model.save_weights 方法用于仅保存模型的权重
  • model.load_weights 方法用于仅加载模型的权重
# 模型保存与加载

# 保存整个模型为SavedModel格式
model.save('my_model')


# 加载保存的模型
loaded_model = tf.keras.models.load_model('my_model')
print("加载的模型结构：", loaded_model.summary())


# 仅保存模型的权重
model.save_weights('my_model_weights.h5')


# 加载模型权重
model.load_weights('my_model_weights.h5')
print("加载权重后的模型结构：", model.summary())

高级功能

分布式训练：

  • tf.distribute.MirroredStrategy 用于单机多GPU训练
  • tf.distribute.MultiWorkerMirroredStrategy 用于多机多GPU训练等，可实现模型在多个设备上的并行训练，提高训练效率
## 高级功能
# 分布式训练
# 使用MirroredStrategy进行单机多GPU训练
strategy = tf.distribute.MirroredStrategy()

# 在策略范围内构建模型和训练
with strategy.scope():
    distributed_model = tf.keras.Sequential([
        tf.keras.layers.Dense(64, activation='relu', input_shape=(784,)),
        tf.keras.layers.Dense(32, activation='relu'),
        tf.keras.layers.Dense(10, activation='softmax')
    ])
    distributed_model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

# 训练分布式模型
distributed_model.fit(x_train, y_train, epochs=5, batch_size=10, validation_data=(x_val, y_val))

自定义操作：

  • tf.raw_ops 访问底层的原生操作
  • tf.py_function 将Python函数包装为TensorFlow操作，实现自定义的计算逻辑
# 自定义操作
# 使用tf.raw_ops访问底层原生操作
raw_add_result = tf.raw_ops.AddV2(x=constant_tensor, y=variable_tensor)
print("使用原生操作的加法结果：", raw_add_result)
# tf.Tensor(
# [[ 6.  8.]
#  [10. 12.]], shape=(2, 2), dtype=float32)


# 使用tf.py_function将Python函数包装为TensorFlow操作
def custom_python_function(x, y):
    return x + y

custom_op_result = tf.py_function(custom_python_function, [constant_tensor, variable_tensor], Tout=tf.float32)
print("自定义操作结果：", custom_op_result)
# tf.Tensor(
# [[ 6.  8.]
#  [10. 12.]], shape=(2, 2), dtype=float32)

自动微分：

  • tf.GradientTape 提供了自动微分的功能，可记录张量的运算过程，并在需要时计算梯度，为自定义模型和优化算法提供了便利
# 自动微分

# 使用tf.GradientTape记录张量的运算过程并计算梯度
with tf.GradientTape() as tape:
    tape.watch(variable_tensor)  # 确保变量被跟踪
    y = tf.reduce_sum(variable_tensor ** 2)

# 计算梯度
gradients = tape.gradient(y, variable_tensor)
print("自动微分计算的梯度：", gradients)
# tf.Tensor(
# [[10. 12.]
#  [14. 16.]], shape=(2, 2), dtype=float32)

模型部署

  • tf.saved_model 模块用于将模型保存为SavedModel格式，方便在不同的平台上进行部署和推理
# 模型部署
# 保存模型为 SavedModel 格式
import tensorflow as tf

# 创建一个简单的模型
model = tf.keras.Sequential([
    tf.keras.layers.Dense(10, activation='relu', input_shape=(5,)),
    tf.keras.layers.Dense(1, activation='sigmoid')
])

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

# 保存模型为 SavedModel 格式
model.save('my_saved_model')

# 加载保存的模型
loaded_model = tf.keras.models.load_model('my_saved_model')

# 测试加载的模型
test_input = tf.constant([[1.0, 2.0, 3.0, 4.0, 5.0]])
print("测试输入：", test_input)  # tf.Tensor([[1. 2. 3. 4. 5.]], shape=(1, 5), dtype=float32)
print("加载模型的预测结果：", loaded_model.predict(test_input))  # [[0.28744078]]
  • tf.lite.TFLiteConverter 用于将TensorFlow模型转换为TensorFlow Lite模型，以便在移动设备和边缘设备上运行
# 将模型转换为 TensorFlow Lite 格式
import tensorflow as tf

# 创建一个简单的模型
model = tf.keras.Sequential([
    tf.keras.layers.Dense(10, activation='relu', input_shape=(5,)),
    tf.keras.layers.Dense(1, activation='sigmoid')
])

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

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

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

# 加载 TensorFlow Lite 模型
interpreter = tf.lite.Interpreter(model_path='model.tflite')
interpreter.allocate_tensors()

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

# 准备输入数据
test_input = tf.constant([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=tf.float32)
interpreter.set_tensor(input_details[0]['index'], test_input)

# 运行模型
interpreter.invoke()

# 获取输出结果
output_data = interpreter.get_tensor(output_details[0]['index'])
print("TensorFlow Lite 模型的预测结果：", output_data)  # [[0.18082538]]

可视化工具

  • TensorBoard：TensorBoard是TensorFlow自带的可视化工具，可通过 tf.summary 模块将训练过程中的日志写入到日志文件中，然后使用TensorBoard读取日志文件，可视化模型的结构、训练过程中的损失值和指标值、权重和梯度的变化等信息，帮助用户更好地了解模型的训练情况和性能表现
## 可视化工具
# TensorBoard
# 使用TensorBoard回调函数记录训练日志
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir='./logs')

# 训练模型并记录日志
model.fit(x_train, y_train, epochs=5, batch_size=10, validation_data=(x_val, y_val), callbacks=[tensorboard_callback])

# 启动TensorBoard（在终端中运行以下命令）
# tensorboard --logdir=./logs

其他功能

音频处理：

  • tf.audio.decode_wav 用于解码WAV格式的音频文件
  • tf.audio.encode_wav 用于编码WAV格式的音频文件
  • tf.audio.spectrogram 用于计算音频信号的频谱图等
# 解码WAV格式的音频文件
audio_binary = tf.io.read_file('example.wav')
audio, sample_rate = tf.audio.decode_wav(audio_binary)
print("解码后的音频：", audio)
print("采样率：", sample_rate)

# 编码WAV格式的音频文件
encoded_audio = tf.audio.encode_wav(audio, sample_rate)
tf.io.write_file('encoded_example.wav', encoded_audio)

文本处理：

  • tf.text.BertTokenizer 用于对文本进行BERT分词
  • tf.text.UnicodeScriptTokenizer 用于根据Unicode脚本对文本进行分词
# 使用BERT分词器对文本进行分词
import tensorflow_text as tf_text
tokenizer = tf_text.BertTokenizer('vocab.txt', token_out_type=tf.int32)
tokens = tokenizer.tokenize(['Hello world', 'TensorFlow is great'])
print("BERT分词结果：", tokens)

# 使用Unicode脚本分词器对文本进行分词
unicode_tokenizer = tf_text.UnicodeScriptTokenizer()
unicode_tokens = unicode_tokenizer.tokenize(['Hello world', 'TensorFlow is great'])
print("Unicode脚本分词结果：", unicode_tokens)

图像处理：

  • tf.image.resize 用于调整图像的大小
  • tf.image.random_crop 用于随机裁剪图像
  • tf.image.rgb_to_grayscale 用于将RGB图像转换为灰度图像
# 调整图像大小
image = tf.random.uniform([28, 28, 3])  # 创建一个随机图像
resized_image = tf.image.resize(image, [56, 56])
print("调整大小后的图像：", resized_image)

# 随机裁剪图像
cropped_image = tf.image.random_crop(image, [20, 20, 3])
print("随机裁剪后的图像：", cropped_image)

# 将RGB图像转换为灰度图像
grayscale_image = tf.image.rgb_to_grayscale(image)
print("灰度图像：", grayscale_image)

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布