关于人工智能:torch实现

@TOC
上面是一个应用 PyTorch 实现自编码器（AE）的示例代码。这个自编码器有两个暗藏层，别离是 128 和 64。

首先，导入必要的库和模块：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

接着，定义一个类来示意咱们的自编码器：

class Autoencoder(nn.Module):
    def __init__(self):
        super(Autoencoder, self).__init__()
        self.encoder = nn.Sequential(nn.Linear(28*28, 128),
            nn.ReLU(),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Linear(64, 32),
            nn.ReLU())
        
        self.decoder = nn.Sequential(nn.Linear(32, 64),
            nn.ReLU(),
            nn.Linear(64, 128),
            nn.ReLU(),
            nn.Linear(128, 28*28),
            nn.Sigmoid())

    def forward(self, x):
        x = self.encoder(x)
        x = self.decoder(x)
        return x

在这里，咱们定义了一个名为 Autoencoder 的类，它继承了 nn.Module 类。咱们的自编码器将输出图像压缩成 32 维的向量，而后再将其解码回原始尺寸。

留神到咱们应用了 Sequential 类来将神经网络层连接起来。这个类容许咱们重叠多个层，并将其作为单个模块解决。其中 ReLU() 函数是激活函数，它在每个暗藏层之后增加非线性变换。这些函数的目标是为了减少模型的表达能力。

对于解码器，咱们应用了 Sigmoid() 函数作为输入层激活函数，将其转换到 0 到 1 之间的范畴内。

接下来，定义一些超参数：

batch_size = 128
learning_rate = 1e-3
num_epochs = 10

而后，加载 MNIST 数据集并进行预处理：

transform = transforms.Compose([transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)

在这里，咱们应用了 transforms 库来定义一个变换，它将图像转换为张量，并归一化其像素值以使其范畴在 - 1 到 1 之间。咱们还定义了一个 DataLoader 对象，用于批量读取数据。

接下来，初始化模型和优化器：

model = Autoencoder()
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

在这里，咱们应用了 MSELoss 作为损失函数，Adam 优化器作为优化算法。

最初，训练模型：

for epoch in range(num_epochs):
    for data in train_loader:
        img, _ = data
        img = img.view(img.size(0), -1)
        recon = model(img)
        loss = criterion(recon, img)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    print('Epoch:{}, Loss:{:.4f}'.format(epoch+1, loss.item()))

在这里，咱们对于每个 epoch，遍历训练数据集，并将每个 batch 的数据加载到模型中。首先将图像展平为一维张量，通过自编码器进行前向流传失去重构后的图像，而后计算重构误差并执行反向流传更新权重。

最初打印出以后 epoch 的损失值。

这就是一个应用 PyTorch 实现的简略自编码器示例。

本文由 mdnice 多平台公布