稀疏自动编码器pytorch实现

好的，以下是一个简单的稀疏自动编码器的 PyTorch 实现：

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

class SparseAutoencoder(nn.Module):
    def __init__(self, input_dim, hidden_dim, sparsity_penalty):
        super(SparseAutoencoder, self).__init__()
        
        self.encoder = nn.Linear(input_dim, hidden_dim)
        self.decoder = nn.Linear(hidden_dim, input_dim)
        self.sparsity_penalty = sparsity_penalty
        self.relu = nn.ReLU()
        self.sigmoid = nn.Sigmoid()
        
    def forward(self, x):
        encoded = self.relu(self.encoder(x))
        decoded = self.sigmoid(self.decoder(encoded))
        return encoded, decoded
    
    def loss(self, x, decoded, encoded):
        reconstruction_loss = nn.functional.binary_cross_entropy(decoded, x)
        sparsity_loss = self.sparsity_penalty * torch.sum(torch.abs(encoded.mean(dim=0) - 0.1))
        return reconstruction_loss + sparsity_loss

# 定义模型和优化器
input_dim = 784
hidden_dim = 128
sparsity_penalty = 0.1
model = SparseAutoencoder(input_dim, hidden_dim, sparsity_penalty)
optimizer = optim.Adam(model.parameters())

# 训练模型
num_epochs = 10
batch_size = 32
data_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=True)

for epoch in range(num_epochs):
    epoch_loss = 0
    for batch in data_loader:
        optimizer.zero_grad()
        x = batch[0].view(-1, input_dim)
        encoded, decoded = model(x)
        loss = model.loss(x, decoded, encoded)
        loss.backward()
        optimizer.step()
        epoch_loss += loss.item()
    print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, epoch_loss/len(data_loader)))

在这个例子中，我们定义了一个 `SparseAutoencoder` 类，它包含了一个编码器和一个解码器，以及一个稀疏惩罚参数。`forward` 函数实现了正向传播，`loss` 函数实现了模型的损失函数，包括重构损失和稀疏惩罚项。然后我们定义了模型和优化器，并使用 PyTorch 的数据加载器来进行训练。