请用一段代码示例一下encoder-decoder

Sure! 这里是一个简单的Transformer模型的 encoder-decoder 实现代码示例：

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


class TransformerEncoder(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers=1, num_heads=8, dropout=0.1):
        super().__init__()
        self.self_attn = nn.MultiheadAttention(hidden_size, num_heads)
        self.fc1 = nn.Linear(hidden_size, input_size)
        self.norm1 = nn.LayerNorm(input_size)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x):
        # Self-Attention
        x, _ = self.self_attn(x, x, x)
        # Layer Normalization
        x = self.norm1(x)
        # Fully Connected layer
        x = self.fc1(x)
        # Dropout
        x = self.dropout(x)

        return x


class TransformerDecoder(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers=1, num_heads=8, dropout=0.1):
        super().__init__()
        self.self_attn = nn.MultiheadAttention(hidden_size, num_heads)
        self.fc1 = nn.Linear(hidden_size, input_size)
        self.norm1 = nn.LayerNorm(input_size)
        self.dropout1 = nn.Dropout(dropout)
        self.multihead_attn = nn.MultiheadAttention(hidden_size, num_heads)
        self.fc2 = nn.Linear(input_size, hidden_size)
        self.norm2 = nn.LayerNorm(hidden_size)
        self.dropout2 = nn.Dropout(dropout)
        self.fc3 = nn.Linear(hidden_size, input_size)

    def forward(self, x, encoder_output):
        # Self-Attention
        x, _ = self.self_attn(x, x, x)
        # Layer Normalization
        x = self.norm1(x)
        # Dropout
        x = self.dropout1(x)
        # Multihead-Attention with Encoder output
        x, _ = self.self_attn(x, encoder_output, encoder_output)
        # Layer Normalization
        x = self.norm2(x)
        # Fully Connected layer
        x = self.fc2(x)
        x = self.dropout2(x)
        # Final Fully Connected layer
        x = self.fc3(x)

        return x

这段代码实现了一个Transformer模型的encoder-decoder架构。其中，Encoder将输入序列转换为其隐层表示，Decoder根据上下文向量生成输出序列。在实现中，我们使用了多头自注意力模块以及一个用于整合Encoder输出的多头注意力模块。同时，我们还加入了Batch-Norm以及Dropout层来防止过拟合。