Transformer Token in vdelava položaja s Kerasom

Predstavitev

Obstaja veliko vodnikov, ki pojasnjujejo, kako transformatorji delujejo, in za ustvarjanje intuicije na njihovem ključnem elementu – vdelavi žetonov in pozicij.

Pozicijsko vdelovanje žetonov je omogočilo transformatorjem, da predstavljajo netoge odnose med žetoni (običajno besedami), kar je veliko boljše pri modeliranju našega kontekstno usmerjenega govora v jezikovnem modeliranju. Medtem ko je postopek razmeroma preprost, je dokaj splošen in izvedbe hitro postanejo običajne.

V tem kratkem vodniku si bomo ogledali, kako lahko uporabimo KerasNLP, uradni dodatek Keras, za izvajanje PositionEmbedding in TokenAndPositionEmbedding.

KerasNLP

KerasNLP je horizontalni dodatek za NLP. V času pisanja je še vedno zelo mlad, v različici 0.3, in dokumentacija je še dokaj kratka, vendar je paket že več kot le uporaben.

Omogoča dostop do plasti Keras, kot je npr TokenAndPositionEmbedding, TransformerEncoder in TransformerDecoder, zaradi česar je izdelava transformatorjev po meri lažja kot kdaj koli prej.

Če želite uporabljati KerasNLP v našem projektu, ga lahko namestite prek pip:

$ pip install keras_nlp

Ko jih uvozite v projekt, lahko uporabite katero koli keras_nlp plast kot standardna plast Keras.

Tokenizacija

Računalniki delajo s številkami. Svoje misli izrazimo z besedami. Da bi omogočili računalniku, da jih premleva, bomo morali v neki obliki preslikati besede v številke.

Pogost način za to je preprosto preslikava besed v številke, kjer vsako celo število predstavlja besedo. Korpus besed tvori besedišče, vsaka beseda v besedišču pa dobi indeks. Tako lahko zaporedje besed spremenite v zaporedje indeksov, znano kot žetonih:

def tokenize(sequence):
    
    return tokenized_sequence

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

To zaporedje žetonov je nato mogoče vdelati v zgoščen vektor, ki definira žetone v latentnem prostoru:

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

To se običajno naredi z Embedding plast v Kerasu. Transformatorji ne kodirajo samo s standardom Embedding plast. Nastopajo Embedding in PositionEmbedding, in jih seštejte, tako da običajne vdelave premaknete glede na njihov položaj v latentnem prostoru.

S KerasNLP – nastopanje TokenAndPositionEmbedding združuje običajno vdelavo žetonov (Embedding) s pozicijsko vdelavo (PositionEmbedding).

PositionEmbedding

Oglejmo si PositionEmbedding prvi. Sprejema tenzorje in raztrgane tenzorje ter predpostavlja, da končna dimenzija predstavlja značilnosti, medtem ko predzadnja dimenzija predstavlja zaporedje.

# Seq
(5, 10)
     # Features

Plast sprejme a sequence_length argument, ki označuje, no, dolžino vhodnega in izhodnega zaporedja. Pojdimo naprej in pozicijsko vdelajmo naključni uniformni tenzor:

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)

Rezultat tega je:

<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

Vdelava žetonov in pozicij se zmanjša na uporabo Embedding na vhodnem zaporedju, PositionEmbedding na vdelane žetone in nato seštevanje teh dveh rezultatov skupaj, učinkovito premaknitev vdelav žetonov v prostoru za kodiranje njihovih relativnih smiselnih odnosov.

To je tehnično mogoče storiti kot:

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 

Vhodi so vdelani in nato pozicijsko vdelani, nakar se seštejejo in ustvarijo novo pozicijsko vdelano obliko. Lahko pa izkoristite TokenAndPositionEmbedding sloj, ki to počne pod pokrovom:

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

Zaradi tega je izvajanje veliko čistejše 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 

Podatki, ki smo jih posredovali v plast, so zdaj položajno vdelani v latentni prostor 10 dimenzij:

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  ],
         ...

Gremo dlje – ročni projekt od konca do konca

Ali zaradi vaše radovedne narave želite iti dlje? Priporočamo, da si ogledate naše Vodeni projekt: »Podnapisi slik s CNN in Transformers s Keras«.

V tem vodenem projektu se boste naučili, kako zgraditi model za napise slike, ki sprejme sliko kot vhod in ustvari besedilni napis kot izhod.

Naučili se boste, kako:

• Predhodna obdelava besedila
• Preprosto vektorizirajte vnos besedila
• Sodelujte z tf.data API in zgradite zmogljive nabore podatkov
• Zgradite transformatorje iz nič s TensorFlow/Keras in KerasNLP – uradnim horizontalnim dodatkom Kerasu za gradnjo najsodobnejših modelov NLP
• Zgradite hibridne arhitekture, kjer je izhod enega omrežja kodiran za drugega

Kako uokvirimo napise slike? Večina meni, da je to primer generativnega poglobljenega učenja, saj učimo omrežje ustvarjati opise. Vendar pa rad gledam na to kot na primer nevronskega strojnega prevajanja – vizualne lastnosti slike prevajamo v besede. S prevajanjem ustvarimo novo predstavitev te podobe, namesto da ustvarimo nov pomen. Če nanj gledamo kot na prevod in samo z generiranjem razširitve, se naloga obravnava v drugačni luči in je nekoliko bolj intuitivna.

Če problem opredelimo kot problem prevajanja, lažje ugotovimo, katero arhitekturo želimo uporabiti. Encoder-only Transformers so odlični pri razumevanju besedila (analiza občutkov, klasifikacija itd.), ker kodirniki kodirajo smiselne predstavitve. Modeli samo z dekoderjem so odlični za generiranje (kot je GPT-3), saj lahko dekoderji sklepajo na smiselne predstavitve v drugem zaporedju z enakim pomenom. Prevajanje se običajno izvaja z arhitekturo kodirnika-dekoderja, kjer kodirniki kodirajo smiselno predstavitev stavka (ali slike, v našem primeru), dekoderji pa se naučijo spremeniti to zaporedje v drugo smiselno predstavitev, ki je za nas bolj razumljiva (kot je stavek).

Sklepi

Transformerji so od leta 2017 naredili velik val in številni odlični vodniki ponujajo vpogled v njihovo delovanje, vendar so bili mnogim še vedno nedosegljivi zaradi dodatnih stroškov implementacij po meri. KerasNLP obravnava to težavo in zagotavlja gradnike, ki vam omogočajo, da zgradite prilagodljive, zmogljive sisteme NLP, namesto da bi zagotovili vnaprej pripravljene rešitve.

V tem priročniku smo si ogledali vdelavo žetonov in položajev s Keras in KerasNLP.