什么是零充气层，如何在火把上实现？

Question

我正在为单细胞RNA-Seq数据的降维构建一个变分自动编码器.我设法用传统的自动编码器绘制了清晰的集群，但我的VAE没有工作。损失减少，但停止在5左右。当我想象的潜在空间，我只是得到一个随机点分散，没有学习模式什么。

我相信问题是我还没有实现紫层。原因是我甚至不明白它的目的，而且数学感觉很不直观。

VASC是一种深变分的自动编码器，它能够捕获非线性变化，并自动学习输入数据的分层表示。其目的之一是简化scRNA-seq数据集的可视化。VASC主要分为三个部分：(1)编码器网络；(2)译码器网络；(3)零充气层。VASC的创建者在这里解释了这一点，不过这里是纸。

1. 紫层背后的解释是什么？
2. 如何在我的解码器组件之后实现它？

class VAE(nn.Module):
    def __init__(self):
        super(VAE, self).__init__()

        self.n_components = 6

        self.fc0 = nn.Dropout(p=0.5)
        # For probabilistic encoder
        self.fc1 = nn.Linear(13714, 128)
        self.fc2 = nn.Linear(128, 32)
        self.fc3 = nn.Linear(32, 16)
        self.fc41 = nn.Linear(16, self.n_components) 
        self.fc42 = nn.Linear(16, self.n_components) 

        # For probabilistic decoder
        self.fc5 = nn.Linear(self.n_components, 16)
        self.fc6 = nn.Linear(16, 32)
        self.fc7 = nn.Linear(32, 128)
        self.fc8 = nn.Linear(128, 13714)

    def encode(self, x):
        h0 = self.fc0(x) #dropout
        h1 = self.fc1(h0)
        h2 = F.relu(self.fc2(h1))
        h3 = F.relu(self.fc3(h2))

        return self.fc41(h3), F.softplus(self.fc42(h3))

    def reparameterize(self, mu, logvar):
        std = torch.exp(0.5*logvar)
        eps = torch.randn_like(std)
        return mu + eps*std

    def decode(self, z):
        h5 = F.relu(self.fc5(z))
        h6 = F.relu(self.fc6(h5))
        h7 = F.relu(self.fc7(h6))
        h8 = torch.sigmoid(self.fc8(h7)) #output layer

        return h8

    def forward(self, x):
        mu, logvar = self.encode(x.view(-1, 13714))
        z = self.reparameterize(mu, logvar)
        return self.decode(z), mu, logvar

model = VAE().to(device)
optimizer = optim.RMSprop(model.parameters(), lr=0.001)

def loss_function(recon_x, x, mu, logvar):
    BCE = F.binary_cross_entropy(recon_x, x.view(-1, 13714), reduction="mean")
    KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())

    return BCE + 0.1*KLD, BCE, KLD

log_interval = 32

for epoch in range(80):
    #model.train()
    running_loss = 0

    for batch_idx, (data, _) in enumerate(train_loader):
        data = data.to(device)
        optimizer.zero_grad()
        recon_batch, mu, logvar = model(data.float())
        loss, bce, kld = loss_function(recon_batch, data.float(), mu, logvar)
        loss.backward()
        running_loss += loss.item()
        optimizer.step()
        if batch_idx % log_interval == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}\tBCE: {:.6f}\tKLD: {:.6f}'.format(
                epoch, batch_idx * len(data), len(train_loader.dataset),
                100. * batch_idx / len(train_loader),
                loss.item(), bce.item(), kld.item()))

    print('====> Epoch: {} Loss: {:.4f}'.format(
          epoch, running_loss))

就像我说过的，潜伏的空间什么也学不到。我认为问题在于缺乏子层。如果没有，请你帮我找出问题，谢谢。

Answer 1

我还没有完全读到你的问题，但是，零膨胀分布是一些概率(例如，q)返回0的分布，对于概率1-q，则是从你想要的分布中返回一个样本。例如，零膨胀负二项分布是一种负二项分布，通过它的抽样，你得到了带概率q的零，从负二项分布得到的抽样数给出了概率1-q。我认为你可以用pyro.distributions.zero_inflated来实现它。