在机器学习模型的开发和调试过程中，我们经常会从简单的玩具数据集开始，以验证模型的正确性和收敛性。然而，即使是针对一个完美的线性关系数据集，有时也会遇到模型收敛不如预期的问题。本教程将通过一个具体的案例，对比tensorflow/keras和pytorch在拟合一个精确线性关系时的表现，并揭示其中一个常见的配置陷阱。
我们首先定义一个数据生成函数，用于创建一个具有精确线性关系的合成数据集。
import numpy as np
def gen_data(n, k):
"""
生成一个具有精确线性关系的数据集。
y = X * beta
"""
np.random.seed(5711) # 保证结果可复现
beta = np.random.uniform(0, 1, size=(k, 1))
print("真实 beta 值:", beta.flatten())
X = np.random.normal(size=(n, k))
y = X.dot(beta).reshape(-1, 1)
D = np.concatenate([X, y], axis=1)
return D.astype(np.float32)
# 生成数据示例
n_samples = 10
n_features = 2
data = gen_data(n_samples, n_features)
print("生成的数据形状:", data.shape)在这个数据集中，y完全由X通过一个固定的beta向量线性组合得到，不包含任何噪声或截距项（偏置）。理想情况下，一个简单的线性模型应该能够很快地学习到这个beta值。
首先，我们使用PyTorch构建一个简单的线性神经网络模型，并观察其收敛行为。
import torch
from torch.utils.data import DataLoader, Dataset
from torch import nn
from sklearn.model_selection import train_test_split
# 数据集类
class Daten(Dataset):
def __init__(self, df):
self.df = df
self.ycol = df.shape[1] - 1
def __getitem__(self, index):
return self.df[index, :self.ycol], self.df[index, self.ycol:]
def __len__(self):
return self.df.shape[0]
# 数据加载器分割函数
def split_into(D, batch_size=64, **kwargs):
D_train, D_test = train_test_split(D, **kwargs)
df_train, df_test = Daten(D_train), Daten(D_test)
dl_train = DataLoader(df_train, batch_size=batch_size)
dl_test = DataLoader(df_test, batch_size=batch_size) # 实际未使用，但保留
return dl_train, dl_test
# 神经网络模型
class NeuralNetwork(nn.Module):
def __init__(self, input_dim):
super().__init__()
self.linear_layer = nn.Sequential(
nn.Linear(input_dim, 1) # 单个线性层
)
def forward(self, x):
return self.linear_layer(x)
# 训练函数
def train_pytorch_model(dataloader, model, loss_fn, optimizer, device):
model.train()
for batch, (X, y) in enumerate(dataloader):
X, y = X.to(device), y.to(device)
pred = model(X)
loss = loss_fn(pred, y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
# 模型训练流程
device = "cpu"
D = gen_data(n_samples, n_features)
dl_train, _ = split_into(D, test_size=0.2)
pytorch_model = NeuralNetwork(n_features).to(device)
loss_fn = nn.MSELoss()
optimizer_pytorch = torch.optim.SGD(pytorch_model.parameters(), lr=1e-1)
print("\nPyTorch 模型训练开始:")
epochs = 50
for t in range(epochs):
train_pytorch_model(dl_train, pytorch_model, loss_fn, optimizer_pytorch)
if (t + 1) % 10 == 0:
# 简单评估一下当前损失
with torch.no_grad():
for X_batch, y_batch in dl_train:
pred = pytorch_model(X_batch)
current_loss = loss_fn(pred, y_batch).item()
print(f"Epoch {t + 1}, Loss: {current_loss:.7f}")
break # 只评估第一个batch的损失
print("PyTorch 训练完成!")
# 打印学习到的权重和偏置
print("PyTorch 学习到的权重 (beta):", pytorch_model.linear_layer[0].weight.data.cpu().numpy())
print("PyTorch 学习到的偏置 (bias):", pytorch_model.linear_layer[0].bias.data.cpu().numpy())通过上述PyTorch代码，我们可以观察到模型在短短50个epoch内，损失迅速下降并接近于零，学习到的权重也与真实值非常接近。
接下来，我们尝试在TensorFlow/Keras中构建一个相同的线性模型。
import keras.layers
from sklearn.model_selection import train_test_split
from keras.models import Sequential
import tensorflow as tf
# 重新生成数据以确保一致性
D_tf = gen_data(n_samples, n_features)
D_train_tf, D_test_tf = train_test_split(D_tf, test_size=0.2, random_state=42) # 添加random_state保证分割一致
X_train_tf, y_train_tf = D_train_tf[:, :n_features], D_train_tf[:, n_features:]
X_test_tf, y_test_tf = D_test_tf[:, :n_features], D_test_tf[:, n_features:]
# 初始的TensorFlow/Keras模型设置 (存在问题)
tf_model_initial = Sequential([keras.layers.Dense(1, input_shape=(n_features,))])
tf_model_initial.compile(optimizer=tf.keras.optimizers.SGD(lr=1e-1), loss=tf.keras.losses.MeanSquaredError())
print("\nTensorFlow/Keras 初始模型训练开始 (使用 lr 参数):")
history_initial = tf_model_initial.fit(X_train_tf, y_train_tf, batch_size=64, epochs=50, verbose=0)
print(f"TensorFlow/Keras 初始模型最终训练损失: {history_initial.history['loss'][-1]:.7f}")
# 打印学习到的权重和偏置
weights_initial = tf_model_initial.get_weights()
print("TensorFlow/Keras 初始模型学习到的权重 (beta):", weights_initial[0].flatten())
print("TensorFlow/Keras 初始模型学习到的偏置 (bias):", weights_initial[1].flatten())我们会发现，尽管设置了相同的学习率和epoch数量，TensorFlow/Keras模型的损失值仍然相对较高，学习到的权重也与真实值存在较大差异。这是为什么呢？
仔细观察TensorFlow的输出，可能会看到一个警告信息： WARNING:absl:lr is deprecated in Keras optimizer, please use learning_rate or use the legacy optimizer, e.g.,tf.keras.optimizers.legacy.SGD.
这个警告信息指出了问题的核心：在TensorFlow 2.x及Keras 3中，tf.keras.optimizers.SGD的lr参数已经被弃用，正确的参数名是learning_rate。如果继续使用lr，优化器可能不会按照预期的学习率进行更新，或者会使用默认值，导致模型收敛缓慢甚至不收敛。
将模型编译代码修改如下：
# 修正后的TensorFlow/Keras模型设置
tf_model_corrected = Sequential([keras.layers.Dense(1, input_shape=(n_features,))])
tf_model_corrected.compile(optimizer=tf.keras.optimizers.SGD(learning_rate=1e-1), loss=tf.keras.losses.MeanSquaredError())
print("\nTensorFlow/Keras 修正模型训练开始 (使用 learning_rate 参数):")
history_corrected = tf_model_corrected.fit(X_train_tf, y_train_tf, batch_size=64, epochs=50, verbose=0)
print(f"TensorFlow/Keras 修正模型最终训练损失: {history_corrected.history['loss'][-1]:.7f}")
# 打印学习到的权重和偏置
weights_corrected = tf_model_corrected.get_weights()
print("TensorFlow/Keras 修正模型学习到的权重 (beta):", weights_corrected[0].flatten())
print("TensorFlow/Keras 修正模型学习到的偏置 (bias):", weights_corrected[1].flatten())通过这个简单的修改，TensorFlow/Keras模型现在也能够快速收敛，并学习到接近真实值的权重。这突显了在不同框架间迁移代码时，即使是看似微小的API变化也可能带来显著影响。
在这个特定的线性数据集中，我们生成的数据 y = X * beta 并没有包含任何截距项（即 y = X * beta + 0）。然而，我们构建的Dense层（或nn.Linear）默认是包含偏置项的。在没有真实偏置的数据中，模型仍然会尝试学习一个偏置值，这可能导致一些有趣的现象：
完美线性关系无偏置： 当数据完全没有偏置时，模型学习到的偏置项应该趋近于零。但由于初始化、优化器行为等因素，它可能不会精确为零，甚至在某些情况下会略微阻碍模型快速找到最优解（因为它需要将一个不必要的参数推向零）。
添加噪声或真实偏置： 如果我们在数据生成时引入了噪声或一个真实的偏置项，例如：
# 在 gen_data 函数中添加这一行 # y += np.random.rand(*y.shape) * 0.2 # 添加随机噪声 # 或者 y += 0.5 # 添加一个固定偏置
在这种情况下，包含偏置项的模型将能够更好地拟合数据，因为现在数据中确实存在一个模型可以学习的截距。此时，模型学习到的偏置项将趋近于真实噪声的平均值或真实的固定偏置值，并且整体损失会更低。
这表明，理解模型组件（如偏置项）与数据特性之间的关系至关重要。在数据本身不含偏置的情况下，如果模型默认包含偏置，它会尝试学习一个零偏置，这可能不会像在数据中确实存在偏置时那样高效。
本教程通过一个具体的案例，展示了在深度学习框架间迁移模型时可能遇到的一个常见问题，并提供了解决方案。以下是几点关键总结和最佳实践：
通过遵循这些实践，开发者可以更有效地构建、调试和优化深度学习模型，避免常见的配置陷阱，并确保模型能够按照预期收敛。
以上就是深入解析TensorFlow与PyTorch线性模型收敛差异及优化策略的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
813
收藏
