你把例子用代码写出来呀

好的，下面是一个使用PyTorch实现的简单的Transformer模型，可以用于上述例子的输入序列。

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


class TransformerBlock(nn.Module):
    def __init__(self, input_dim, hidden_dim, num_heads, dropout_rate):
        super(TransformerBlock, self).__init__()

        self.self_attn = nn.MultiheadAttention(input_dim, num_heads)
        self.feed_forward = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.ReLU(),
            nn.Dropout(dropout_rate),
            nn.Linear(hidden_dim, input_dim),
            nn.Dropout(dropout_rate)
        )
        self.layer_norm1 = nn.LayerNorm(input_dim)
        self.layer_norm2 = nn.LayerNorm(input_dim)

    def forward(self, x, mask=None):
        # Multi-head self-attention layer
        attn_output, _ = self.self_attn(x, x, x, attn_mask=mask)
        # Layer normalization and residual connection
        x = self.layer_norm1(x + attn_output)
        # Feed-forward layer
        ffn_output = self.feed_forward(x)
        # Layer normalization and residual connection
        x = self.layer_norm2(x + ffn_output)
        return x


class TransformerModel(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim, num_layers, num_heads, dropout_rate):
        super(TransformerModel, self).__init__()

        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.pos_encoding = nn.Parameter(torch.zeros(1, 100, embedding_dim))
        self.dropout = nn.Dropout(dropout_rate)
        self.num_layers = num_layers
        self.transformer_blocks = nn.ModuleList([
            TransformerBlock(embedding_dim, hidden_dim, num_heads, dropout_rate)
            for _ in range(num_layers)
        ])
        self.fc = nn.Linear(embedding_dim, vocab_size)

    def forward(self, x):
        x = self.embedding(x) + self.pos_encoding[:, :x.size(1), :]
        x = self.dropout(x)
        mask = self._generate_mask(x)
        for i in range(self.num_layers):
            x = self.transformer_blocks[i](x, mask)
        x = self.fc(x)
        return x

    def _generate_mask(self, x):
        mask = torch.zeros(x.size(1), x.size(1)).bool()
        mask = torch.triu(mask, diagonal=1)
        return mask.to(x.device)

这个模型包含了一个Transformer块的实现（`TransformerBlock`类），以及一个完整的Transformer模型的实现（`TransformerModel`类），可以用于对输入序列进行编码和解码。

在模型的`forward`方法中，我们首先将输入序列进行词嵌入和位置编码，然后通过一个dropout层进行随机失活。接下来，我们生成一个mask矩阵，用于在多头自注意力层中屏蔽掉未来的信息。然后，我们将输入序列输入到多个Transformer块中，每个块都由一个多头自注意力层和一个前馈神经网络层组成。最后，我们将最终输出通过一个线性层进行分类，得到每个单词的预测概率。