用pytorch写transformer代码

好的，这里是一份简单的PyTorch代码示例，实现了Transformer模型：

import torch
import torch.nn as nn
import torch.nn.functional as F

class TransformerModel(nn.Module):
    def __init__(self, num_tokens, d_model, num_heads, num_layers, dim_feedforward):
        super().__init__()
        self.d_model = d_model
        self.token_embedding = nn.Embedding(num_tokens, d_model)
        self.pos_embedding = nn.Embedding(1000, d_model)
        self.layer_stack = nn.ModuleList([
            TransformerLayer(d_model, num_heads, dim_feedforward)
            for _ in range(num_layers)
        ])
        self.fc = nn.Linear(d_model, num_tokens)
        
    def forward(self, x):
        seq_len = x.shape[1]
        pos = torch.arange(seq_len, dtype=torch.long)
        pos = pos.unsqueeze(0).expand(x.shape[0], seq_len)
        x = self.token_embedding(x) + self.pos_embedding(pos)
        for layer in self.layer_stack:
            x = layer(x)
        x = self.fc(x)
        return x
    
class TransformerLayer(nn.Module):
    def __init__(self, d_model, num_heads, dim_feedforward):
        super().__init__()
        self.self_attn = MultiHeadAttention(d_model, num_heads)
        self.feed_forward = nn.Sequential(
            nn.Linear(d_model, dim_feedforward),
            nn.ReLU(),
            nn.Linear(dim_feedforward, d_model)
        )
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        
    def forward(self, x):
        attn_output = self.self_attn(x, x, x)
        x = self.norm1(x + attn_output)
        ff_output = self.feed_forward(x)
        x = self.norm2(x + ff_output)
        return x
    
class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads):
        super().__init__()
        self.num_heads = num_heads
        self.d_model = d_model
        self.depth = d_model // num_heads
        self.query_lin = nn.Linear(d_model, num_heads * self.depth)
        self.key_lin = nn.Linear(d_model, num_heads * self.depth)
        self.value_lin = nn.Linear(d_model, num_