在自然语言处理（NLP）中，Transformer 模型是一个非常重要的里程碑，它通过自注意力（self-attention）机制极大地提高了处理序列数据的能力。在 Transformer 模型中，词嵌入（Word Embedding）是输入层的关键部分，负责将离散的单词转换成连续的向量表示，以便模型能够理解和处理。然而，您提到的“Postin Embedding”可能是一个笔误，通常我们讨论的是“Position Embedding”（位置嵌入），它用于给模型提供单词在句子中的位置信息，因为 Transformer 模型本身是位置无关的。

以下是一个基于 PyTorch 的简单 Transformer 模型实现，包括词嵌入和位置嵌入的详细代码示例。这个示例将展示如何构建 Transformer 的一个基本层（包括多头自注意力机制和前馈网络），并加入位置嵌入。

import torch  
import torch.nn as nn  
import torch.nn.functional as F  
  
class PositionalEncoding(nn.Module):  
    def __init__(self, d_model, max_len=5000):  
        super(PositionalEncoding, self).__init__()  
        # 创建位置编码矩阵  
        pe = torch.zeros(max_len, d_model)  
        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)  
        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))  
        pe[:, 0::2] = torch.sin(position * div_term)  
        pe[:, 1::2] = torch.cos(position * div_term)  
        pe = pe.unsqueeze(0).transpose(0, 1)  
        self.register_buffer('pe', pe)  
  
    def forward(self, x):  
        # 将位置编码加到词嵌入上  
        return x + self.pe[:x.size(0), :]  
  
class TransformerEncoderLayer(nn.Module):  
    def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1):  
        super(TransformerEncoderLayer, self).__init__()  
        self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)  
        self.linear1 = nn.Linear(d_model, dim_feedforward)  
        self.dropout = nn.Dropout(dropout)  
        self.linear2 = nn.Linear(dim_feedforward, d_model)  
  
        self.norm1 = nn.LayerNorm(d_model)  
        self.norm2 = nn.LayerNorm(d_model)  
        self.dropout1 = nn.Dropout(dropout)  
        self.dropout2 = nn.Dropout(dropout)  
  
        self.activation = nn.ReLU()  
  
    def forward(self, src, src_mask=None, src_key_padding_mask=None):  
        src2 = self.norm1(src)  
        src2 = self.dropout1(src2)  
        src_out, attn_output_weights, attn_output_mask = self.self_attn(src2, src2, src2, attn_mask=src_mask,  
                                                                      key_padding_mask=src_key_padding_mask)  
        src = src + self.dropout2(src_out)  
        src2 = self.norm2(src)  
        src2 = self.dropout(src2)  
        src = self.linear2(self.dropout(self.activation(self.linear1(src2))))  
        src = src + src2  
        return src, attn_output_weights  
  
class TransformerEncoder(nn.Module):  
    def __init__(self, encoder_layer, num_layers, d_model, vocab_size, max_len=5000):  
        super(TransformerEncoder, self).__init__()  
        self.layer = nn.ModuleList([encoder_layer for _ in range(num_layers)])  
        self.src_emb = nn.Embedding(vocab_size, d_model)  
        self.pos_encoder = PositionalEncoding(d_model, max_len)  
  
    def forward(self, src):  
        src = self.src_emb(src) * math.sqrt(self.d_model)  # scale embedding by sqrt(d_model)  
        src = self.pos_encoder(src)  
        output = src  
        attn = None  
  
        for encoder in self.layer:  
            output, attn = encoder(output)  
  
        return output, attn  
  
# 示例参数  
vocab_size = 10000  # 假设词汇表大小为 10000  
d_model = 512        # 嵌入维度  
nhead = 8            # 多头注意力机制中的头数  
num_layers = 6       # 编码器层数  
  
# 创建 TransformerEncoder  
encoder_layer = TransformerEncoderLayer(d_model=d_model, nhead=nhead)  
transformer_encoder = TransformerEncoder(encoder_layer, num_layers, d_model, vocab_size)  
  
# 示例输入（假设已经有一些经过编码的索引）  
src = torch.tensor([[1, 2, 3, 4, 5, 0, 0],  # 每个句子的索引，用 0 填充到相同长度  
                     [6, 7, 8, 9, 10, 0, 0]], dtype=torch.long)  
  
# 传递输入到 Transformer 编码器  
output, attn = transformer_encoder(src)  
  
print("Encoder output shape:", output.shape)  # 应该是 [batch_size, seq_len, d_model]  
print("Attention weights shape (if you need them):", attn.shape)  # 注意 attn 可能在第一层之后才是有效的  
  
# 注意：attn 的输出在这里可能不直接显示，因为它依赖于具体的层实现和是否传递了 mask。  
# 在实际应用中，你可能需要更复杂的逻辑来处理 mask 或直接忽略 attn 的输出。
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.
  • 41.
  • 42.
  • 43.
  • 44.
  • 45.
  • 46.
  • 47.
  • 48.
  • 49.
  • 50.
  • 51.
  • 52.
  • 53.
  • 54.
  • 55.
  • 56.
  • 57.
  • 58.
  • 59.
  • 60.
  • 61.
  • 62.
  • 63.
  • 64.
  • 65.
  • 66.
  • 67.
  • 68.
  • 69.
  • 70.
  • 71.
  • 72.
  • 73.
  • 74.
  • 75.
  • 76.
  • 77.
  • 78.
  • 79.
  • 80.
  • 81.
  • 82.
  • 83.
  • 84.
  • 85.
  • 86.
  • 87.
  • 88.

以上代码实现了一个简单的 Transformer 编码器，包括词嵌入、位置嵌入、多头自注意力机制和前馈网络。在 TransformerEncoderLayer 类中，我们定义了一个编码器层，它包含了自注意力机制、层归一化、前馈网络以及相应的dropout层。TransformerEncoder 类则将这些层堆叠起来，并添加了词嵌入和位置嵌入。

请注意，在实际应用中，你可能需要添加一些额外的功能，比如掩码（mask）来处理填充的零或进行序列到序列的任务（例如翻译），以及添加解码器部分以构建完整的 Transformer 模型。此外，上述代码没有处理变长输入序列的掩码，这在实际应用中是很重要的，因为它可以防止模型关注到填充的零。