用pytorch写一个卷积自编码器

好的，下面是一个简单的卷积自编码器的实现代码，使用PyTorch框架。

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.datasets as dset
import torchvision.transforms as transforms
from torch.autograd import Variable
from torchvision.utils import save_image

# 定义超参数
num_epochs = 100
batch_size = 128
learning_rate = 1e-3

# 加载数据集
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])
train_dataset = dset.MNIST(root='./data', train=True, download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)

# 定义卷积自编码器模型
class AutoEncoder(nn.Module):
    def __init__(self):
        super(AutoEncoder, self).__init__()
        self.encoder = nn.Sequential(
            nn.Conv2d(1, 16, kernel_size=3, stride=3, padding=1),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(16, 8, kernel_size=3, stride=2, padding=1),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=2, stride=1)
        )
        self.decoder = nn.Sequential(
            nn.ConvTranspose2d(8, 16, kernel_size=3, stride=2),
            nn.ReLU(True),
            nn.ConvTranspose2d(16, 8, kernel_size=5, stride=3, padding=1),
            nn.ReLU(True),
            nn.ConvTranspose2d(8, 1, kernel_size=2, stride=2, padding=1),
            nn.Tanh()
        )

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

# 实例化模型
model = AutoEncoder()

# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# 训练模型
for epoch in range(num_epochs):
    for data in train_loader:
        img, _ = data
        img = Variable(img)
        optimizer.zero_grad()
        output = model(img)
        loss = criterion(output, img)
        loss.backward()
        optimizer.step()

    # 每训练10个epoch就保存一次重构图片
    if epoch % 10 == 0:
        pic = output.data
        save_image(pic, './output/image_{}.png'.format(epoch))

    # 输出损失值
    print('epoch [{}/{}], loss:{:.4f}'.format(epoch+1, num_epochs, loss.data))

以上代码中，我们首先定义了一个`AutoEncoder`类，其中包含了一个`encoder`和一个`decoder`。`encoder`用于将输入图片压缩成一个较小的向量，`decoder`则将这个向量解码成一个重构的图片。我们使用了`nn.Conv2d`和`nn.ConvTranspose2d`来定义卷积层和反卷积层，使用了`nn.MaxPool2d`来进行下采样。

在模型训练过程中，我们使用了`nn.MSELoss`作为损失函数，使用了`optim.Adam`作为优化器。每训练10个epoch就保存一次重构图片，并输出当前损失值。

希望以上代码对您有所帮助！