Embedding e positional encoding

Modelli Transformer con PyTorch

James Chapman

Curriculum Manager, DataCamp

Embedding e positional encoding nei transformer

Embedding: token → vettore di embedding
Positional encoding: Posizione del token + vettore di embedding → positional encoding

I componenti di token embedding e positional encoding evidenziati nell'architettura transformer.

Embedding di sequenze

Tre token: Hello, world e un punto esclamativo.

Embedding di sequenze

I tre token convertiti in ID token in base al vocabolario del modello.

Embedding di sequenze

Gli ID token mappati in vettori di una data dimensionalità.

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)

Prassi standard: scalare per $\sqrt{d_{model}}$

Creare embedding

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

Positional encoding

I token embedding e i positional embedding sommati per aggiungere l'informazione di posizione agli input embedding.

Positional encoding

I valori dispari del positional embedding sono calcolati con la funzione seno, quelli pari con la funzione coseno.

sin(x)

La funzione seno.

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

cos(x)

La funzione coseno.

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

Costruire un positional encoder

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

Creare positional encoding

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

Esercitiamoci!

Modelli Transformer con PyTorch