写一个自编码器的pytorch代码

### 回答1：
可以的，以下是一个简单的自编码器的 PyTorch 代码：

import torch
import torch.nn as nn

class Autoencoder(nn.Module):
    def __init__(self):
        super(Autoencoder, self).__init__()
        self.encoder = nn.Sequential(
            nn.Linear(784, 128),
            nn.ReLU(True),
            nn.Linear(128, 64),
            nn.ReLU(True),
            nn.Linear(64, 12),
            nn.ReLU(True),
            nn.Linear(12, 2))
        self.decoder = nn.Sequential(
            nn.Linear(2, 12),
            nn.ReLU(True),
            nn.Linear(12, 64),
            nn.ReLU(True),
            nn.Linear(64, 128),
            nn.ReLU(True),
            nn.Linear(128, 784),
            nn.Tanh())

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

这是一个基于全连接层的自编码器，输入为 784 维的 MNIST 手写数字图像，经过编码器压缩成 2 维的向量，再通过解码器还原成 784 维的图像。

### 回答2：
以下是一个使用PyTorch编写的简单自编码器的示例代码：

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

# 定义自编码器模型
class Autoencoder(nn.Module):
    def __init__(self, input_size, hidden_size):
        super(Autoencoder, self).__init__()
        self.encoder = nn.Linear(input_size, hidden_size)
        self.decoder = nn.Linear(hidden_size, input_size)

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

# 设置超参数和模型
input_size = 100
hidden_size = 50
num_epochs = 10
batch_size = 32
learning_rate = 0.001

model = Autoencoder(input_size, hidden_size)

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

# 生成随机数据作为训练数据
train_data = torch.randn((1000, input_size))

# 开始训练
for epoch in range(num_epochs):
    for i in range(0, train_data.size(0), batch_size):
        inputs = train_data[i:i+batch_size]

        # 前向传播
        outputs = model(inputs)

        # 计算损失
        loss = criterion(outputs, inputs)

        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    # 每个epoch打印一次损失
    print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))

# 使用训练好的自编码器模型进行重建
test_data = torch.randn((10, input_size))
reconstructed_data = model(test_data)

# 打印重建后的数据
print('Reconstructed Data:')
print(reconstructed_data)

以上代码实现了一个简单的自编码器模型。模型的输入维度为`input_size`，隐藏层维度为`hidden_size`。在训练过程中，使用随机数据`train_data`作为训练数据，通过计算重建数据与原始数据之间的均方误差作为损失函数，并使用Adam优化器进行优化。在每个epoch结束后，打印当前的损失。训练完成后，使用训练好的模型对随机数据`test_data`进行重建，并打印出重建后的数据。

请注意，这只是一个简单的自编码器模型示例，具体的模型结构和训练数据需要根据具体问题进行调整。