एंबेडिंग और पोज़िशनल एनकोडिंग

PyTorch के साथ Transformer Models

James Chapman

Curriculum Manager, DataCamp

ट्रांसफॉर्मर्स में एंबेडिंग और पोज़िशनल एनकोडिंग

Embedding: tokens → एंबेडिंग वेक्टर
Positional encoding: टोकन पोज़िशन + एंबेडिंग वेक्टर → पोज़िशनल एनकोडिंग

ट्रांसफॉर्मर आर्किटेक्चर में टोकन एंबेडिंग और पोज़िशनल एनकोडिंग हाइलाइटेड।

सीक्वेंस एंबेड करना

तीन टोकन: Hello, world, और विस्मयादिबोधक चिह्न.

सीक्वेंस एंबेड करना

मॉडल के शब्दकोश पर आधारित, तीनों टोकन को टोकन IDs में बदला गया।

सीक्वेंस एंबेड करना

टोकन IDs को दी गई डाइमेंशनलिटी के वेक्टर में एंबेड किया गया।

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)

मानक प्रैक्टिस: $\sqrt{d_{model}}$ से स्केल करना

एंबेडिंग बनाना

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

पोज़िशनल एनकोडिंग

इनपुट एंबेडिंग में पोज़िशन जानकारी जोड़ने के लिए, टोकन और पोज़िशनल एंबेडिंग को जोड़ा गया।

पोज़िशनल एनकोडिंग

विषम पोज़िशनल एंबेडिंग मान sin फंक्शन से और सम मान cosine फंक्शन से निकाले जाते हैं।

sin(x)

sin फंक्शन.

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

cos(x)

cosine फंक्शन.

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

पोज़िशनल एनकोडर बनाना

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

पोज़िशनल एनकोडिंग बनाना

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

अभ्यास करते हैं!

PyTorch के साथ Transformer Models