Transformer Token og Position Embedding med Keras

Introduktion

Der er masser af vejledninger, der forklarer, hvordan transformere fungerer, og til at opbygge en intuition på et nøgleelement af dem - token- og positionsindlejring.

Positionel indlejring af tokens gjorde det muligt for transformatorer at repræsentere ikke-stive forhold mellem tokens (normalt ord), hvilket er meget bedre til at modellere vores kontekstdrevne tale i sprogmodellering. Selvom processen er relativt enkel, er den ret generisk, og implementeringerne bliver hurtigt standard.

I denne korte guide tager vi et kig på, hvordan vi kan bruge KerasNLP, den officielle Keras-tilføjelse, til at udføre PositionEmbedding , TokenAndPositionEmbedding.

KerasNLP

KerasNLP er en horisontal tilføjelse til NLP. I skrivende stund er den stadig meget ung, i version 0.3, og dokumentationen er stadig ret kort, men pakken er mere end bare brugbar allerede.

Det giver adgang til Keras-lag, som f.eks TokenAndPositionEmbedding, TransformerEncoder , TransformerDecoder, hvilket gør det nemmere end nogensinde før at bygge tilpassede transformere.

For at bruge KerasNLP i vores projekt, kan du installere det via pip:

$ pip install keras_nlp

Når du er importeret til projektet, kan du bruge enhver keras_nlp lag som et standard Keras-lag.

tokenization

Computere arbejder med tal. Vi udtrykker vores tanker i ord. For at give computeren mulighed for at komme igennem dem, bliver vi nødt til at kortlægge ord til tal i en eller anden form.

En almindelig måde at gøre dette på er simpelthen at kortlægge ord til tal, hvor hvert heltal repræsenterer et ord. Et korpus af ord skaber et ordforråd, og hvert ord i ordforrådet får et indeks. Således kan du omdanne en sekvens af ord til en sekvens af indekser kendt som poletter:

def tokenize(sequence):
    
    return tokenized_sequence

sequence = ['I', 'am', 'Wall-E']
sequence = tokenize(sequence)
print(sequence) 

Denne sekvens af tokens kan derefter indlejres i en tæt vektor, der definerer tokens i latent rum:

[[4], [26], [472]] -> [[0.5, 0.25], [0.73, 0.2], [0.1, -0.75]]

Dette gøres typisk med Embedding lag i Keras. Transformere koder ikke kun ved hjælp af en standard Embedding lag. De optræder Embedding , PositionEmbedding, og føj dem sammen, og forskyd de almindelige indlejringer efter deres placering i latent rum.

Med KerasNLP – optrædende TokenAndPositionEmbedding kombinerer almindelig token-indlejring (Embedding) med positionel indlejring (PositionEmbedding).

PositionIndlejring

Lad os tage et kig på PositionEmbedding først. Den accepterer tensorer og ujævne tensorer og antager, at den endelige dimension repræsenterer funktionerne, mens den næstsidste dimension repræsenterer sekvensen.

# Seq
(5, 10)
     # Features

Laget accepterer en sequence_length argument, der angiver længden af ​​input- og outputsekvensen. Lad os gå videre og positionelt indlejre en tilfældig ensartet tensor:

seq_length = 5
input_data = tf.random.uniform(shape=[5, 10])

input_tensor = keras.Input(shape=[None, 5, 10])
output = keras_nlp.layers.PositionEmbedding(sequence_length=seq_length)(input_tensor)
model = keras.Model(inputs=input_tensor, outputs=output)
    
model(input_data)

Dette resulterer i:

<tf.Tensor: shape=(5, 10), dtype=float32, numpy=
array([[ 0.23758471, -0.16798696, -0.15070847,  0.208067  , -0.5123104 ,
        -0.36670157,  0.27487397,  0.14939266,  0.23843127, -0.23328197],
       [-0.51353353, -0.4293166 , -0.30189738, -0.140344  , -0.15444171,
        -0.27691704,  0.14078277, -0.22552207, -0.5952263 , -0.5982155 ],
       [-0.265581  , -0.12168896,  0.46075982,  0.61768025, -0.36352775,
        -0.14212841, -0.26831496, -0.34448475,  0.4418767 ,  0.05758983],
       [-0.46500492, -0.19256318, -0.23447984,  0.17891657, -0.01812166,
        -0.58293337, -0.36404118,  0.54269964,  0.3727749 ,  0.33238482],
       [-0.2965023 , -0.3390794 ,  0.4949159 ,  0.32005525,  0.02882379,
        -0.15913549,  0.27996767,  0.4387421 , -0.09119213,  0.1294356 ]],
      dtype=float32)>

TokenAndPositionEmbedding

Token og position indlejring koger ned til at bruge Embedding på inputsekvensen, PositionEmbedding på de indlejrede tokens, og derefter tilføje disse to resultater sammen, hvilket effektivt forskyder token-indlejringerne i rummet for at indkode deres relative meningsfulde relationer.

Dette kan teknisk gøres som:

seq_length = 10
vocab_size = 25
embed_dim = 10

input_data = tf.random.uniform(shape=[5, 10])

input_tensor = keras.Input(shape=[None, 5, 10])
embedding = keras.layers.Embedding(vocab_size, embed_dim)(input_tensor)
position = keras_nlp.layers.PositionEmbedding(seq_length)(embedding)
output = keras.layers.add([embedding, position])
model = keras.Model(inputs=input_tensor, outputs=output)
    
model(input_data).shape 

Indgangene er indlejret og derefter positionelt indlejret, hvorefter de lægges sammen, hvilket producerer en ny positionelt indlejret form. Alternativt kan du udnytte TokenAndPositionEmbedding lag, som gør dette under hætten:

... 
def call(self, inputs):
        embedded_tokens = self.token_embedding(inputs)
        embedded_positions = self.position_embedding(embedded_tokens)
        outputs = embedded_tokens + embedded_positions
        return outputs

Dette gør det meget renere at udføre TokenAndPositionEmbedding:

seq_length = 10
vocab_size = 25
embed_dim = 10

input_data = tf.random.uniform(shape=[5, 10])

input_tensor = keras.Input(shape=[None, 5, 10])
output = keras_nlp.layers.TokenAndPositionEmbedding(vocabulary_size=vocab_size, 
                                                     sequence_length=seq_length, 
                                                     embedding_dim=embed_dim)(input_tensor)
model = keras.Model(inputs=input_tensor, outputs=output)
    
model(input_data).shape 

De data, vi har sendt ind i laget, er nu positionelt indlejret i et latent rum med 10 dimensioner:

model(input_data)

<tf.Tensor: shape=(5, 10, 10), dtype=float32, numpy=
array([[[-0.01695484,  0.7656435 , -0.84340465,  0.50211895,
         -0.3162892 ,  0.16375223, -0.3774369 , -0.10028353,
         -0.00136751, -0.14690581],
        [-0.05646318,  0.00225556, -0.7745967 ,  0.5233861 ,
         -0.22601983,  0.07024342,  0.0905793 , -0.46133494,
         -0.30130145,  0.451248  ],
         ...

Gå videre – Håndholdt ende-til-ende-projekt

Din nysgerrige natur giver dig lyst til at gå længere? Vi anbefaler at tjekke vores Vejledt projekt: "Billedtekstning med CNN'er og Transformers med Keras".

I dette guidede projekt – lærer du, hvordan du bygger en billedtekstmodel, som accepterer et billede som input og producerer en tekstuel billedtekst som output.

Du lærer at:

• Forbehandle tekst
• Vektoriser tekstinput nemt
• Arbejd med tf.data API og opbygge effektive datasæt
• Byg transformatorer fra bunden med TensorFlow/Keras og KerasNLP – den officielle horisontale tilføjelse til Keras til at bygge state-of-the-art NLP-modeller
• Byg hybridarkitekturer, hvor output fra ét netværk er kodet til et andet

Hvordan rammer vi billedtekster? De fleste betragter det som et eksempel på generativ dyb læring, fordi vi lærer et netværk at generere beskrivelser. Men jeg kan godt lide at se på det som et eksempel på neural maskinoversættelse – vi oversætter de visuelle træk ved et billede til ord. Gennem oversættelse genererer vi en ny repræsentation af det billede, snarere end blot at skabe ny mening. At se det som oversættelse, og kun ved udvidelsesgenerering, omfavner opgaven i et andet lys og gør det en smule mere intuitivt.

At indramme problemet som et oversættelsesproblem gør det lettere at finde ud af, hvilken arkitektur vi vil bruge. Encoder-only Transformers er gode til at forstå tekst (sentimentanalyse, klassificering osv.), fordi encodere koder for meningsfulde repræsentationer. Dekoder-only-modeller er gode til generation (såsom GPT-3), da dekodere er i stand til at udlede meningsfulde repræsentationer i en anden sekvens med samme betydning. Oversættelse udføres typisk af en encoder-dekoder-arkitektur, hvor indkodere koder en meningsfuld repræsentation af en sætning (eller billede, i vores tilfælde), og dekodere lærer at omdanne denne sekvens til en anden meningsfuld repræsentation, der er mere fortolkelig for os (såsom en sætning).

konklusioner

Transformere har lavet en stor bølge siden 2017, og mange gode guider giver indsigt i, hvordan de fungerer, men alligevel var de stadig uhåndgribelige for mange på grund af overhead af tilpassede implementeringer. KerasNLP løser dette problem ved at levere byggeklodser, der lader dig bygge fleksible, kraftfulde NLP-systemer, i stedet for at levere færdigpakkede løsninger.

I denne guide har vi taget et kig på token- og positionsindlejring med Keras og KerasNLP.