TensorFlow训练：数据分割与数值稳定技巧

问题重述

如摘要所述，问题在于使用 TensorFlow 的 tf.data.Dataset 构建数据集时，未分割的完整数据集在训练模型时会导致损失函数变为 NaN，而将数据集分割成训练集和测试集后，模型训练则正常进行。尽管两种数据集的预处理方式相同，但训练结果却截然不同。

原因分析：数据尺度与梯度爆炸

根本原因很可能是数据尺度问题与梯度爆炸的结合。当神经网络的输入数据尺度过大，且模型中使用了如 ReLU 等激活函数时，容易导致梯度爆炸。具体来说：

1. 数据尺度过大： 从问题描述中的数据样本可以看出，input1 和 input2 的数值范围差异很大，且数值本身可能偏大。未经缩放的数据直接输入模型，会导致模型权重在训练初期就发生较大的变化。
2. ReLU 激活函数： ReLU 函数在正区间上的导数为 1，这使得梯度能够无衰减地传递，从而加剧了梯度爆炸的可能性。如果某个神经元的输入经过 ReLU 后变得很大，那么它的梯度也会很大，从而导致其权重发生剧烈变化。
3. 数据集大小的影响： 完整数据集包含更多的数据，这意味着每个 epoch 中模型会进行更多的梯度更新。在未经缩放的数据上进行更多次的梯度更新，会加速权重爆炸的过程，从而更快地导致 NaN 值的出现。分割后的数据集由于数据量减少，权重爆炸的速度相对较慢，可能在训练结束前还未出现 NaN 值。

解决方案：数据标准化

解决此问题的关键在于对数据进行标准化处理，将数据缩放到一个合适的范围内，避免梯度爆炸。常用的标准化方法包括：

• StandardScaler (Z-score 标准化): 将数据缩放到均值为 0，标准差为 1 的范围内。
• MinMaxScaler: 将数据缩放到 [0, 1] 的范围内。

推荐使用 StandardScaler，因为它对异常值不敏感，且能够更好地保持数据的分布形状。

实现步骤：

1. 分割数据集： 首先，将完整数据集分割成训练集和测试集。务必先分割数据集，再进行标准化，防止信息泄露。
2. 拟合 StandardScaler： 使用训练集数据拟合 StandardScaler 对象，计算训练集的均值和标准差。
3. 转换数据： 使用拟合好的 StandardScaler 对象分别转换训练集和测试集数据。

代码示例：

import tensorflow as tf
from sklearn.preprocessing import StandardScaler
import numpy as np

# 假设 full_dataset 已经加载，并且是 tf.data.Dataset 对象

# 1. 分割数据集
def is_test(x, _):
    return x % 10 == 0  # 假设 10% 作为测试集

def is_train(x, y):
    return not is_test(x, y)

recover = lambda x, y: y

# Split the dataset for training.
test_set = full_dataset.enumerate().filter(is_test).map(recover)

# Split the dataset for testing/validation.
trainning_set = full_dataset.enumerate().filter(is_train).map(recover)

# 2. 提取数据并转换为 NumPy 数组
def extract_data(dataset):
  input1_list = []
  input2_list = []
  target_list = []
  for element in dataset:
    inputs, target = element
    input1_list.append(inputs['input1'].numpy())
    input2_list.append(inputs['input2'].numpy())
    target_list.append(target.numpy())
  return np.concatenate(input1_list, axis=0), np.concatenate(input2_list, axis=0), np.array(target_list)


input1_train, input2_train, target_train = extract_data(trainning_set)
input1_test, input2_test, target_test = extract_data(test_set)

# 3. 训练 StandardScaler 并转换数据
scaler_input1 = StandardScaler()
scaler_input2 = StandardScaler()
scaler_target = StandardScaler()

input1_train_scaled = scaler_input1.fit_transform(input1_train.reshape(-1, input1_train.shape[-1])).reshape(input1_train.shape)
input2_train_scaled = scaler_input2.fit_transform(input2_train)
target_train_scaled = scaler_target.fit_transform(target_train.reshape(-1,1))

input1_test_scaled = scaler_input1.transform(input1_test.reshape(-1, input1_test.shape[-1])).reshape(input1_test.shape)
input2_test_scaled = scaler_input2.transform(input2_test)
target_test_scaled = scaler_target.transform(target_test.reshape(-1,1))


# 4. 创建新的 tf.data.Dataset 对象
def create_dataset(input1, input2, target):
    def generator():
        for i in range(len(input1)):
            yield ({'input1': input1[i], 'input2': input2[i]}, target[i])

    return tf.data.Dataset.from_generator(
        generator,
        output_signature=(
            {'input1': tf.TensorSpec(shape=input1.shape[1:], dtype=tf.float32),
             'input2': tf.TensorSpec(shape=input2.shape[1:], dtype=tf.float32)},
            tf.TensorSpec(shape=target.shape[1:], dtype=tf.float32)
        )
    )

trainning_set_scaled = create_dataset(input1_train_scaled, input2_train_scaled, target_train_scaled)
test_set_scaled = create_dataset(input1_test_scaled, input2_test_scaled, target_test_scaled)

trainning_set_scaled = trainning_set_scaled.batch(batch_size).cache().prefetch(2)
test_set_scaled = test_set_scaled.batch(batch_size).cache().prefetch(2)


# 使用标准化后的数据训练模型
model.fit(trainning_set_scaled, validation_data=test_set_scaled)

注意事项：

• 在测试集和预测时，必须使用与训练集相同的 StandardScaler 对象进行转换。
• tf.data.Dataset 对象不易直接操作，需要先转换为 NumPy 数组才能进行标准化。
• 如果模型预测结果需要还原到原始尺度，可以使用 scaler.inverse_transform() 方法。

总结

当 TensorFlow 模型在完整数据集上训练时出现 NaN 值，而在分割后的数据集上训练正常时，很可能是由于数据尺度过大导致梯度爆炸。通过使用 StandardScaler 对数据进行标准化处理，可以有效地解决这个问题，确保模型训练的数值稳定性。记住，先分割数据集，再进行标准化，并使用相同的 StandardScaler 对象转换训练集和测试集数据。