Transformatortoken och positionsinbäddning med Keras

Beskrivning

Det finns gott om guider som förklarar hur transformatorer fungerar och för att bygga en intuition på ett nyckelelement i dem – token- och positionsinbäddning.

Positionell inbäddning av tokens gjorde det möjligt för transformatorer att representera icke-rigida relationer mellan tokens (vanligtvis ord), vilket är mycket bättre på att modellera vårt kontextdrivna tal i språkmodellering. Även om processen är relativt enkel, är den ganska generisk, och implementeringarna blir snabbt standard.

I den här korta guiden tar vi en titt på hur vi kan använda KerasNLP, det officiella Keras-tillägget, för att utföra PositionEmbedding och TokenAndPositionEmbedding.

KerasNLP

KerasNLP är ett horisontellt tillägg för NLP. När det skrivs är det fortfarande väldigt ungt, i version 0.3, och dokumentationen är fortfarande ganska kort, men paketet är mer än bara användbart redan.

Det ger tillgång till Keras-lager, som t.ex TokenAndPositionEmbedding, TransformerEncoder och TransformerDecoder, vilket gör det enklare än någonsin att bygga anpassade transformatorer.

För att använda KerasNLP i vårt projekt kan du installera det via pip:

$ pip install keras_nlp

När du har importerat till projektet kan du använda vilken som helst keras_nlp lager som ett standard Keras lager.

tokenization

Datorer fungerar med siffror. Vi uttrycker våra tankar i ord. För att datorn ska kunna gå igenom dem måste vi mappa ord till siffror i någon form.

Ett vanligt sätt att göra detta är att helt enkelt mappa ord till siffror där varje heltal representerar ett ord. En korpus av ord skapar en vokabulär, och varje ord i vokabulären får ett index. Således kan du förvandla en sekvens av ord till en sekvens av index som kallas token:

def tokenize(sequence):
    
    return tokenized_sequence

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

Denna sekvens av tokens kan sedan bäddas in i en tät vektor som definierar tokens i latent utrymme:

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

Detta görs vanligtvis med Embedding lager i Keras. Transformatorer kodar inte bara med en standard Embedding lager. De uppträder Embedding och PositionEmbedding, och lägg ihop dem, förskjuter de vanliga inbäddningarna efter deras position i latent utrymme.

Med KerasNLP – uppträdande TokenAndPositionEmbedding kombinerar vanlig tokeninbäddning (Embedding) med positionsinbäddning (PositionEmbedding).

PositionInbäddning

Låt oss ta en titt på PositionEmbedding först. Den accepterar tensorer och trasiga tensorer och antar att den slutliga dimensionen representerar funktionerna, medan den näst sista dimensionen representerar sekvensen.

# Seq
(5, 10)
     # Features

Lagret accepterar en sequence_length argument, som anger, ja, längden på ingångs- och utmatningssekvensen. Låt oss gå vidare och positionellt bädda in en slumpmässig enhetlig 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)

Detta resulterar 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- och positionsinbäddning handlar om att använda Embedding på inmatningssekvensen, PositionEmbedding på de inbäddade tokens och sedan lägga till dessa två resultat tillsammans, vilket effektivt förskjuter tokeninbäddningarna i rymden för att koda deras relativa meningsfulla relationer.

Detta kan tekniskt göras 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 

Ingångarna bäddas in och bäddas sedan in positionsmässigt, varefter de läggs samman, vilket ger en ny positionsmässigt inbäddad form. Alternativt kan du utnyttja TokenAndPositionEmbedding lager, som gör detta under huven:

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

Detta gör det mycket renare att utföra 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 

Datan vi har skickat in i lagret är nu positionsmässigt inbäddad i ett latent utrymme 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å vidare – Handhållet End-to-End-projekt

Din nyfikna natur gör att du vill gå längre? Vi rekommenderar att du kollar in vår Guidade projekt: "Bildtextning med CNN och Transformers med Keras".

I det här guidade projektet – kommer du att lära dig hur du bygger en bildtextningsmodell, som accepterar en bild som indata och producerar en textbild som utdata.

Du lär dig hur du:

• Förbearbeta text
• Vektorisera textinmatning enkelt
• Arbeta med tf.data API och bygg presterande datamängder
• Bygg transformatorer från grunden med TensorFlow/Keras och KerasNLP – det officiella horisontella tillägget till Keras för att bygga toppmoderna NLP-modeller
• Bygg hybridarkitekturer där utdata från ett nätverk kodas för ett annat

Hur ramar vi in ​​bildtextning? De flesta anser att det är ett exempel på generativt djupt lärande, eftersom vi lär ett nätverk att generera beskrivningar. Men jag gillar att se det som ett exempel på neural maskinöversättning – vi översätter de visuella egenskaperna hos en bild till ord. Genom översättning genererar vi en ny representation av den bilden, snarare än att bara generera ny mening. Att se det som översättning, och endast genom förlängningsgenerering, omfångar uppgiften i ett annat ljus och gör det lite mer intuitivt.

Att rama in problemet som ett översättningsproblem gör det lättare att ta reda på vilken arkitektur vi vill använda. Transformers endast för kodare är bra på att förstå text (sentimentanalys, klassificering, etc.) eftersom kodare kodar meningsfulla representationer. Modeller med endast avkodare är bra för generering (som GPT-3), eftersom avkodare kan sluta sig till meningsfulla representationer till en annan sekvens med samma betydelse. Översättning görs vanligtvis av en kodare-avkodararkitektur, där kodare kodar en meningsfull representation av en mening (eller bild, i vårt fall) och avkodare lär sig att förvandla denna sekvens till en annan meningsfull representation som är mer tolkbar för oss (som en mening).

Slutsatser

Transformatorer har skapat en stor våg sedan 2017, och många bra guider ger insikt i hur de fungerar, men de var fortfarande svårfångade för många på grund av överkostnaderna med anpassade implementeringar. KerasNLP löser detta problem och tillhandahåller byggstenar som låter dig bygga flexibla, kraftfulla NLP-system, snarare än att tillhandahålla färdigförpackade lösningar.

I den här guiden har vi tagit en titt på token- och positionsinbäddning med Keras och KerasNLP.