Encodage d'embedding et positionnel

Modèles Transformer avec PyTorch

James Chapman

Curriculum Manager, DataCamp

Embedding et encodage positionnel dans les transformers

Embedding : jetons → vecteur d'embedding
Encodage positionnel : position du jeton + vecteur d'embedding → encodage positionnel

Les composantes d'embedding des jetons et d'encodage positionnel mises en évidence dans l'architecture transformer.

Embarquer des séquences

Trois jetons : Hello, world et un point d'exclamation.

Embarquer des séquences

Les trois jetons convertis en ID de jetons selon le vocabulaire du modèle.

Embarquer des séquences

Les ID de jetons transformés en vecteurs d'une dimension donnée.

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)

Pratique courante : mise à l'échelle par $\sqrt{d_{model}}$

Créer des embeddings

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])

Encodage positionnel

Les embeddings de jetons et positionnels sont additionnés pour ajouter l'information de position aux embeddings d'entrée.

Encodage positionnel

Les valeurs d'encodage positionnel d'indice impair sont calculées avec la fonction sinus, et celles d'indice pair avec la fonction cosinus.

sin(x)

La fonction sinus.

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

cos(x)

La fonction cosinus.

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

Construire un encodeur positionnel

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)]

Créer des encodages positionnels

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])

Passons à la pratique !

Modèles Transformer avec PyTorch