Transformatortoken og posisjonsinnbygging med Keras

Introduksjon

Det er mange guider som forklarer hvordan transformatorer fungerer, og for å bygge en intuisjon på et sentralt element i dem – symbol- og posisjonsinnbygging.

Posisjonelt innebygde tokens tillot transformatorer å representere ikke-stive forhold mellom tokens (vanligvis ord), som er mye bedre til å modellere vår kontekstdrevne tale i språkmodellering. Selv om prosessen er relativt enkel, er den ganske generisk, og implementeringene blir raskt standard.

I denne korte guiden tar vi en titt på hvordan vi kan bruke KerasNLP, det offisielle Keras-tillegget, til å utføre PositionEmbedding og TokenAndPositionEmbedding.

KerasNLP

KerasNLP er et horisontalt tillegg for NLP. I skrivende stund er den fortsatt veldig ung, i versjon 0.3, og dokumentasjonen er fortsatt ganske kort, men pakken er mer enn bare brukbar allerede.

Det gir tilgang til Keras-lag, som f.eks TokenAndPositionEmbedding, TransformerEncoder og TransformerDecoder, som gjør det enklere enn noen gang å bygge tilpassede transformatorer.

For å bruke KerasNLP i prosjektet vårt, kan du installere det via pip:

$ pip install keras_nlp

Når du er importert til prosjektet, kan du bruke hvilken som helst keras_nlp lag som et standard Keras-lag.

tokenization

Datamaskiner jobber med tall. Vi uttrykker tankene våre i ord. For å la datamaskinen knase gjennom dem, må vi kartlegge ord til tall i en eller annen form.

En vanlig måte å gjøre dette på er å ganske enkelt kartlegge ord til tall der hvert heltall representerer et ord. Et korpus av ord lager et ordforråd, og hvert ord i ordforrådet får en indeks. Dermed kan du gjøre en sekvens av ord om til en sekvens av indekser kjent som poletter:

def tokenize(sequence):
    
    return tokenized_sequence

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

Denne sekvensen av tokens kan deretter bygges inn i en tett vektor som definerer tokens i latent rom:

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

Dette gjøres vanligvis med Embedding lag i Keras. Transformatorer koder ikke bare ved å bruke en standard Embedding lag. De opptrer Embedding og PositionEmbedding, og legg dem sammen, og forskyv de vanlige innebyggingene etter deres plassering i latent rom.

Med KerasNLP – opptreden TokenAndPositionEmbedding kombinerer vanlig token-innbygging (Embedding) med posisjonell innebygging (PositionEmbedding).

Posisjon Innebygging

La oss ta en titt på PositionEmbedding først. Den aksepterer tensorer og fillete tensorer, og antar at den endelige dimensjonen representerer funksjonene, mens den nest siste dimensjonen representerer sekvensen.

# Seq
(5, 10)
     # Features

Laget godtar en sequence_length argument, som angir, vel, lengden på inngangs- og utgangssekvensen. La oss gå videre og posisjonelt legge inn en tilfeldig uniform 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 posisjon innebygging koker ned til å bruke Embedding på inngangssekvensen, PositionEmbedding på de innebygde tokenene, og deretter legge disse to resultatene sammen, og effektivt forskyve token-innbyggingene i rommet for å kode deres relative meningsfulle relasjoner.

Dette kan teknisk sett gjø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 

Inndataene er innebygd, og deretter posisjonelt innebygd, hvoretter de legges sammen, og produserer en ny posisjonelt innebygd form. Alternativt kan du utnytte TokenAndPositionEmbedding lag, som gjør dette under panseret:

... 
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 gjør det mye renere å utfø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 

Dataene vi har sendt inn i laget er nå posisjonsmessig innebygd i et latent rom med 10 dimensjoner:

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-prosjekt

Din nysgjerrige natur gjør at du ønsker å gå lenger? Vi anbefaler å sjekke ut vår Veiledet prosjekt: "Bildeteksting med CNN og Transformers med Keras".

I dette guidede prosjektet – vil du lære hvordan du bygger en bildetekstmodell, som godtar et bilde som input og produserer en tekstuell bildetekst som utdata.

Du lærer hvordan du:

• Forbehandle tekst
• Vektoriser tekstinntasting enkelt
• Arbeid med tf.data API og bygg ytelsesdatasett
• Bygg transformatorer fra bunnen av med TensorFlow/Keras og KerasNLP – det offisielle horisontale tillegget til Keras for å bygge state-of-the-art NLP-modeller
• Bygg hybridarkitekturer der utdataene fra ett nettverk er kodet for et annet

Hvordan rammer vi inn bildeteksting? De fleste anser det som et eksempel på generativ dyp læring, fordi vi lærer et nettverk å generere beskrivelser. Imidlertid liker jeg å se på det som et eksempel på nevral maskinoversettelse – vi oversetter de visuelle egenskapene til et bilde til ord. Gjennom oversettelse genererer vi en ny representasjon av det bildet, i stedet for bare å generere ny mening. Å se den som oversettelse, og bare ved utvidelsesgenerering, ser på oppgaven i et annet lys, og gjør den litt mer intuitiv.

Å sette inn problemet som et oversettelsesproblem gjør det lettere å finne ut hvilken arkitektur vi vil bruke. Encoder-bare transformatorer er gode til å forstå tekst (sentimentanalyse, klassifisering, etc.) fordi kodere koder for meningsfulle representasjoner. Modeller som kun er dekodere er flotte for generering (som GPT-3), siden dekodere er i stand til å utlede meningsfulle representasjoner til en annen sekvens med samme betydning. Oversettelse gjøres vanligvis av en koder-dekoder-arkitektur, der kodere koder for en meningsfull representasjon av en setning (eller et bilde, i vårt tilfelle) og dekodere lærer å gjøre denne sekvensen om til en annen meningsfull representasjon som er mer tolkbar for oss (for eksempel en setning).

Konklusjoner

Transformatorer har laget en stor bølge siden 2017, og mange gode guider gir innsikt i hvordan de fungerer, men de var fortsatt unnvikende for mange på grunn av overheaden til tilpassede implementeringer. KerasNLP løser dette problemet, og gir byggeklosser som lar deg bygge fleksible, kraftige NLP-systemer, i stedet for å tilby ferdigpakkede løsninger.

I denne veiledningen har vi tatt en titt på token- og posisjonsinnbygging med Keras og KerasNLP.