Vkládání a poziční kódování

Transformer Models with PyTorch

James Chapman

Curriculum Manager, DataCamp

Vkládání a poziční kódování v transformerech

Vkládání: tokeny → vektor reprezentace
Poziční kódování: pozice tokenu + vektor reprezentace → poziční kódování

Komponenty tokenového vkládání a pozičního kódování zvýrazněné v architektuře transformeru.

Vkládání sekvencí

Tři tokeny: Hello, world a vykřičník.

Vkládání sekvencí

Tři tokeny převedené na ID tokenů na základě slovníku modelu.

Vkládání sekvencí

ID tokenů vložená do vektorů dané dimenzionality.

import torch
import math
import torch.nn as nn

class InputEmbeddings(nn.Module):

    def __init__(self, vocab_size: int, d_model: int) -> None:
        super().__init__()
        self.d_model = d_model
        self.vocab_size = vocab_size
        self.embedding = nn.Embedding(vocab_size, d_model)


    def forward(self, x):
        return self.embedding(x) * math.sqrt(self.d_model)

Standardní praxe: škálování pomocí $\sqrt{d_{model}}$

Vytváření vektorových reprezentací

embedding_layer = InputEmbeddings(vocab_size=10_000, d_model=512)

embedded_output = embedding_layer(torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8]]))

print(embedded_output.shape)

torch.Size([2, 4, 512])

Poziční kódování

Tokenové a poziční vektory jsou sečteny, čímž se poziční informace přidá k vstupním vektorům.

Poziční kódování

Liché hodnoty pozičního kódování se počítají funkcí sinus, sudé hodnoty funkcí kosinus.

sin(x)

Funkce sinus.

$$ PE_{(pos, 2i)}=\sin(\frac{pos}{10000^{2i/d_{model}}}) $$

cos(x)

Funkce kosinus.

$$ PE_{(pos, 2i+1)}=\cos(\frac{pos}{10000^{2i/d_{model}}}) $$

Vytvoření pozičního enkodéru

class PositionalEncoding(nn.Module):
    def __init__(self, d_model, max_seq_length):
        super().__init__()

        pe = torch.zeros(max_seq_length, d_model)

        position = torch.arange(0, max_seq_length, dtype=torch.float).unsqueeze(1)

        div_term = torch.exp(torch.arange(0, d_model, 2, dtype=torch.float) * -(math.log(10000.0) / d_model))

        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)


        self.register_buffer('pe', pe.unsqueeze(0))


    def forward(self, x):
        return x + self.pe[:, :x.size(1)]

Vytváření pozičních kódování

pos_encoding_layer = PositionalEncoding(d_model=512, max_seq_length=4)

pos_encoded_output = pos_encoding_layer(embedded_output)

print(pos_encoded_output.shape)

torch.Size([2, 4, 512])

Pojďme si procvičit!

Transformer Models with PyTorch