Bộ mã hóa transformer

Các mô hình Transformer với PyTorch

James Chapman

Curriculum Manager, DataCamp

Transformer gốc

Kiến trúc transformer như trong bài báo Attention Is All You Need.

Transformer gốc

Kiến trúc transformer gốc

Transformer chỉ encoder

Kiến trúc transformer chỉ encoder

Thân transformer: chồng encoder với N tầng encoder

Tầng encoder

Self-attention đa đầu

(Các) tầng con feed-forward

Chuẩn hóa tầng, dropout

Đầu transformer

Transformer chỉ encoder

Kiến trúc transformer chỉ encoder

Thân transformer: chồng encoder với N tầng encoder

Tầng encoder

Self-attention đa đầu

(Các) tầng con feed-forward

Chuẩn hóa tầng, dropout

Đầu transformer: xử lý đầu vào đã mã hóa để tạo dự đoán đầu ra

Bài toán giám sát: phân loại, hồi quy

Tầng con feed-forward trong các tầng encoder

Tầng con feed-forward sau attention

class FeedForwardSubLayer(nn.Module):
    def __init__(self, d_model, d_ff):
        super().__init__()
        self.fc1 = nn.Linear(d_model, d_ff)
        self.fc2 = nn.Linear(d_ff, d_model)
        self.relu = nn.ReLU()


    def forward(self, x):
        return self.fc2(self.relu(self.fc1(x)))

2 lớp fully connected + kích hoạt ReLU

d_ff: kích thước trung gian giữa các lớp tuyến tính
forward(): xử lý đầu ra attention để bắt các mẫu phức tạp, phi tuyến

Tầng encoder

class EncoderLayer(nn.Module):
    def __init__(self, d_model, num_heads, d_ff, dropout):
        super().__init__()
        self.self_attn = MultiHeadAttention(d_model, num_heads)
        self.ff_sublayer = FeedForwardSubLayer(d_model, d_ff)

        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.dropout = nn.Dropout(dropout)


    def forward(self, x, src_mask):
        attn_output = self.self_attn(x, x, x, src_mask)
        x = self.norm1(x + self.dropout(attn_output))
        ff_output = self.ff_sublayer(x)
        x = self.norm2(x + self.dropout(ff_output))
        return x

Tầng encoder

Self-attention đa đầu
Tầng con feed-forward
Chuẩn hóa tầng và dropout

forward():

mask tránh xử lý các token padding

Masking trong quá trình attention

Đệm chuỗi (padding)

Mặt nạ padding trong self-attention

Thân encoder transformer

class TransformerEncoder(nn.Module):
    def __init__(self, vocab_size, d_model, num_layers, num_heads, d_ff, dropout, max_seq_length):
        super().__init__()

        self.embedding = InputEmbeddings(vocab_size, d_model)

        self.positional_encoding = PositionalEncoding(d_model, max_seq_length)

        self.layers = nn.ModuleList(
          [EncoderLayer(d_model, num_heads, d_ff, dropout) for _ in range(num_layers)]
        )


    def forward(self, x, src_mask):
        x = self.embedding(x)
        x = self.positional_encoding(x)
        for layer in self.layers:
            x = layer(x, src_mask)
        return x

Đầu encoder transformer

class ClassifierHead(nn.Module):
    def __init__(self, d_model, num_classes):
        super().__init__()
        self.fc = nn.Linear(d_model, num_classes)

    def forward(self, x):
        logits = self.fc(x)
        return F.log_softmax(logits, dim=-1)

class RegressionHead(nn.Module):
    def __init__(self, d_model, output_dim):
        super().__init__()
        self.fc = nn.Linear(d_model, output_dim)

    def forward(self, x):
        return self.fc(x)

Đầu phân loại (classification head)

Nhiệm vụ: phân loại văn bản, phân tích cảm xúc, NER, QA trích xuất, v.v.
fc: lớp tuyến tính fully connected
- Chuyển trạng thái ẩn của encoder thành xác suất num_classes

Đầu hồi quy (regression head)

Nhiệm vụ: ước lượng độ dễ đọc, độ phức tạp ngôn ngữ, v.v.
- output_dim bằng 1 khi dự đoán một giá trị số duy nhất

Ayo berlatih!

Các mô hình Transformer với PyTorch