Keras 自编码器转 PyTorch 实现 - 代码对比和优化

Keras 自编码器转 PyTorch 实现 - 代码对比和优化

本文将演示如何将使用 Keras 构建的自动编码器模型转化为 PyTorch 代码，并提供代码优化建议，以提升模型训练效率和性能。

Keras 代码:

input_data = Input(shape=(len(SampleFeature[0]),))
encoded_input = Input(shape=(encoding_dim2,))
# dense 是全连接层 ---- embedding
# 公式（12）
encoded1 = Dense(encoding_dim1, activation='relu')(input_data)
encoded2 = Dense(encoding_dim2, activation='relu')(encoded1)
decoded1 = Dense(encoding_dim1, activation='relu')(encoded2)
# 公式（13）
decoded2 = Dense(1114, activation='sigmoid')(decoded1)

autoencoder = Model(inputs=input_data, outputs=decoded2)
decoder_layer = autoencoder.layers[-1]
encoder = Model(inputs=input_data, outputs=encoded2)
# Adam 优化
# loss 函数为 二元交叉熵 binary_cross entropy
# 公式（14）
autoencoder.compile(optimizer=Adam(lr=0.001, beta_1=0.9, beta_2=0.999,
                                   epsilon=None, decay=0.0, amsgrad=False), loss='binary_crossentropy')
# 每次迭代 数据大小为128 迭代300次
# 在验证损失不再改善5个时期时停止训练 早期停止策略
autoencoder.fit(x_train, x_train, epochs=300, batch_size=128, shuffle=True,
                validation_data=(x_test, x_test),callbacks=[EarlyStopping(monitor='val_loss', min_delta=0.0001, patience=5)])

PyTorch 代码:

import torch
import torch.nn as nn
import torch.optim as optim

class Autoencoder(nn.Module):
    def __init__(self, encoding_dim1, encoding_dim2):
        super(Autoencoder, self).__init__()
        self.encoder1 = nn.Linear(1114, encoding_dim1)
        self.encoder2 = nn.Linear(encoding_dim1, encoding_dim2)
        self.decoder1 = nn.Linear(encoding_dim2, encoding_dim1)
        self.decoder2 = nn.Linear(encoding_dim1, 1114)
        self.activation = nn.ReLU()
        self.sigmoid = nn.Sigmoid()

    def encode(self, x):
        x = self.activation(self.encoder1(x))
        x = self.activation(self.encoder2(x))
        return x
    
    def decode(self, x):
        x = self.activation(self.decoder1(x))
        x = self.sigmoid(self.decoder2(x))
        return x

    def forward(self, x):
        x = self.encode(x)
        x = self.decode(x)
        return x

autoencoder = Autoencoder(encoding_dim1, encoding_dim2)
optimizer = optim.Adam(autoencoder.parameters(), lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0, amsgrad=False)
criterion = nn.BCELoss()

# 将数据转换为 Tensor
x_train_tensor = torch.tensor(x_train, dtype=torch.float32)
x_test_tensor = torch.tensor(x_test, dtype=torch.float32)

# 每次迭代数据大小为128，迭代300次
# 在验证损失不再改善5个时期时停止训练 早期停止策略
for epoch in range(300):
    for i in range(0, len(x_train_tensor), 128):
        batch_x = x_train_tensor[i:i+128]
        output = autoencoder(batch_x)
        loss = criterion(output, batch_x)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    with torch.no_grad():
        val_output = autoencoder(x_test_tensor)
        val_loss = criterion(val_output, x_test_tensor)
    if epoch % 10 == 0:
        print("Epoch: {}, Train Loss: {:.5f}, Val Loss: {:.5f}".format(epoch+1, loss.item(), val_loss.item()))
    if val_loss < best_loss:
        best_loss = val_loss
        patience = 0
    else:
        patience += 1
    if patience >= 5:
        print("Early stopping...")
        break

# 获取编码器
encoder = nn.Sequential(
    autoencoder.encoder1,
    autoencoder.activation,
    autoencoder.encoder2,
    autoencoder.activation
)

代码对比和优化:

1. 模型定义: Keras 使用 Input 和 Model 来定义模型结构，PyTorch 使用 nn.Module 类。PyTorch 代码更简洁，并利用了面向对象的特性，可以方便地扩展和修改模型。
2. 损失函数: Keras 使用 compile 方法指定损失函数，PyTorch 使用 nn.BCELoss() 对象。
3. 优化器: Keras 使用 Adam 类，PyTorch 使用 optim.Adam 类。
4. 训练过程: Keras 使用 fit 方法训练模型，PyTorch 使用手动循环遍历数据，并调用 optimizer.step() 更新参数。PyTorch 代码更灵活，可以更好地控制训练过程。
5. 早停机制: Keras 使用 EarlyStopping 回调函数，PyTorch 使用手动实现。PyTorch 代码需要手动记录验证损失和 patience 值，以判断是否停止训练。
6. 编码器获取: Keras 使用 Model 类创建编码器，PyTorch 使用 nn.Sequential 类。PyTorch 代码更简洁，并可以方便地获取模型的特定层。

代码优化建议:

1. 使用 torch.utils.data.DataLoader 加载数据，可以提高数据读取效率。
2. 使用 nn.DataParallel 或 torch.distributed.launch 等技术进行多 GPU 训练，可以加速模型训练。
3. 使用 torch.backends.cudnn.benchmark = True 开启 CUDNN 性能优化，可以提高模型运行速度。
4. 使用 torch.profiler 分析模型运行时间，找到性能瓶颈，并进行优化。

结论:

本文演示了如何将使用 Keras 构建的自动编码器模型转化为 PyTorch 代码，并提供了代码优化建议。通过利用 PyTorch 的灵活性和高效性，可以更好地构建和训练深度学习模型。