在自然語言處理（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 的輸出。
以上程式碼實現了一個簡單的 Transformer 編碼器，包括詞嵌入、位置嵌入、多頭自注意力機制和前饋網路。在 TransformerEncoderLayer 類中，我們定義了一個編碼器層，它包含了自注意力機制、層歸一化、前饋網路以及相應的dropout層。TransformerEncoder 類則將這些層堆疊起來，並新增了詞嵌入和位置嵌入。
請注意，在實際應用中，你可能需要新增一些額外的功能，比如掩碼（mask）來處理填充的零或進行序列到序列的任務（例如翻譯），以及新增解碼器部分以構建完整的 Transformer 模型。此外，上述程式碼沒有處理變長輸入序列的掩碼，這在實際應用中是很重要的，因為它可以防止模型關注到填充的零。