卷积/全连接自编码器实现Embedding转译失败原因与可行架构探讨

问题描述 #

我用PyTorch搭建了一个CNN自编码器网络A，能把最长50个token的短句嵌入到512维空间，经过256维瓶颈层后可以完美重构原句。现在想提取这个网络输出的256维Embedding，输入到网络B里实现源句Embedding到目标句Embedding的转译。

试了两种方案都未成功：

• 方案一：提取Embedding后用简单全连接网络加MSELoss做转译，但损失始终降不下来；
• 方案二：用VAE（带重参数化技巧）让网络B生成和输入Embedding相似的结果，同样损失居高不下，完全没有下降趋势。

想搞懂以下问题：

1. 为什么这个思路行不通？模型为啥学不了Embedding到Embedding的转译？
2. 为啥这套方案在图像任务里能用，文本任务就不行？要直观的逻辑解释。
3. 如果把网络A换成Transformer或RNN架构，这个思路能不能行？

代码示例 #

网络A（CNN自编码器） #

import torch
import torch.nn as nn

class CNNEncode(nn.Module):
    def __init__(self):
        super().__init__()
        # 注：原代码中vocab_size、n_embed、max_l为外部定义的变量
        self.embed = nn.Embedding(vocab_size, n_embed*4)
        self.conv1 = nn.Conv1d(n_embed*4, max_l, 3, stride=3, padding=1, dilation = 2)
        self.relu = nn.ReLU(inplace=True)
        self.conv2 = nn.Conv1d(max_l, n_embed*1, 3, stride=3, padding=1, dilation = 4)
        self.fc = nn.Linear(512, 256)
        self.fc2 = nn.Linear(256, 64*max_l)
        self.ln = nn.LayerNorm(256)
        self.ln2 = nn.LayerNorm(64, 1)
        self.out = nn.Linear(64, vocab_size)

    def forward(self, x):
        emb = self.embed(x)
        B,T,C = emb.shape
        emb = emb.view(B, C, T)
        logits = self.conv1(emb)
        logits = self.relu(logits)
        logits = self.conv2(logits)
        logits = self.relu(logits)
        B,T,C = logits.shape
        logits = logits.view(B, -1)
        logits = torch.tanh(logits)
        # 这一步是256维瓶颈层特征
        logits = self.fc(logits)
        logits = self.ln(logits)
        logits = self.fc2(logits)
        logits = self.relu(logits)
        logits = logits.view(B, max_l, 64)
        out = self.out(logits)
        return out

VAE网络（方案二尝试） #

class VariationalAutoEncoder(nn.Module):
    def __init__(self, input_dim, n_dim=128, h_dim=100, z_dim=64):
        super().__init__()
        # encoder，输入为网络A提取的256维Embedding
        self.img_2hid = nn.Linear(256, h_dim)
        self.hid_2mu = nn.Linear(h_dim, z_dim)
        self.hid_2sigma = nn.Linear(h_dim, z_dim)
        
        # decoder
        self.z_2hid = nn.Linear(z_dim, h_dim)
        self.hid_2img = nn.Linear(h_dim, 256)
        
        self.relu = nn.ReLU()
        self.sig = nn.Sigmoid()
    
    def encode(self, x):
        h = self.relu(self.img_2hid(x))
        h = self.sig(h)
        mu = self.hid_2mu(h)
        sigma = self.hid_2sigma(h)
        return mu, sigma
    
    def decode(self, z):
        h = self.relu(self.z_2hid(z))
        return self.sig(self.hid_2img(h))
        
    def forward(self, x):
        mu, sigma = self.encode(x)
        epsilon = torch.randn_like(sigma)
        z_parametrized = mu + sigma* epsilon
        x_reconstructed = self.decode(z_parametrized)
        return x_reconstructed, mu, sigma

# 初始化示例
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
lr = 1e-3
model = VariationalAutoEncoder(input_dim=max_l, n_dim=128, h_dim=200, z_dim=64).to(device)
opt = torch.optim.Adam(model.parameters(), lr=lr)
print(sum(p.nelement() for p in model.parameters()))
loss_fn = nn.BCELoss(reduction = "sum")

核心问题解析 #

1. 为什么当前思路失效？ #

• 瓶颈层Embedding的目标偏差：网络A的训练目标是重构原句，因此256维瓶颈层学到的是「能还原token序列的局部/统计特征」，而非「转译所需的抽象语义等价性」。比如它可能记住了token的顺序、高频搭配，但没编码"句子表达的核心含义"——而转译需要的是不同句子间的语义映射，不是单纯的自我还原。
• 损失函数完全偏离需求：你用MSELoss或VAE的重构损失，本质是要求网络B生成「数值上和源Embedding接近的向量」，但数值接近≠语义等价。比如"我吃饭"和"我用餐"的语义一致，但它们的重构Embedding可能差异极大；反之，数值接近的向量可能语义完全无关，这种损失根本没抓住转译的核心。
• VAE的使用错误：你的VAE用了BCELoss，但网络A输出的256维Embedding是经tanh和LayerNorm处理的、分布在0附近的实数，并非0-1区间的概率值，这会导致损失计算完全失真，自然无法下降。而且VAE的目标是生成同分布样本，不是做语义转译，方向本身就错了。
• Embedding提取可能有误：网络A的forward返回的是最终的vocab logits，如果你没正确提取self.ln(logits)这一层的256维特征，喂给网络B的可能是无效数据。

2. 为啥图像任务可行，文本不行？ #

• 数据本质差异：图像是连续的空间信号，相邻像素有强相关性，自编码器的瓶颈特征编码的是「全局视觉语义」（比如物体形状、纹理），转译（如图像风格迁移）可以基于这些特征做映射——因为视觉语义的连续性强，数值接近的特征往往对应相似的视觉内容。
• 文本是离散符号系统：文本的语义依赖符号的组合逻辑，而非连续数值的相似性。自编码器学到的瓶颈特征是为了还原token序列，可能只编码了token的统计规律，而非抽象语义。比如"我吃饭"和"我吃菜"的重构特征可能很接近，但语义不同；"我吃饭"和"我用餐"语义相同，但重构特征可能差异极大。这种离散特性导致"数值相似=语义相似"的假设完全不成立，图像的思路自然无法迁移。

3. 换Transformer/RNN架构可行吗？ #

有机会可行，但需要调整目标和损失：

• Transformer/RNN天生擅长捕捉序列的语义依赖，它们的中间层Embedding（比如BERT的[CLS] token、RNN的最后一层全局池化特征）能编码更丰富的抽象语义，而非单纯的token还原特征，更适合做语义转译的基础。
• 但不能再用MSELoss或重构损失，要换成语义匹配类损失：比如用对比学习损失（让源句Embedding和目标句Embedding在空间中尽可能近，和负样本尽可能远），或者直接用有监督方式，让网络B的输出与目标句的Embedding（由同一Transformer/RNN编码）做语义对齐。

内容的提问来源于stack exchange，提问作者J. Fenigan