Osadzanie tokenów transformatora i pozycji w Keras

Wprowadzenie

Istnieje wiele poradników wyjaśniających, jak działają transformatory oraz budujących intuicję na ich kluczowym elemencie – osadzeniu tokenów i pozycji.

Osadzanie pozycyjne tokenów umożliwiło transformatorom reprezentowanie niesztywnych relacji między tokenami (zwykle słowami), co znacznie lepiej modeluje naszą mowę opartą na kontekście w modelowaniu językowym. Chociaż proces jest stosunkowo prosty, jest dość ogólny, a implementacje szybko stają się szablonowe.

W tym krótkim przewodniku przyjrzymy się, w jaki sposób możemy używać KerasNLP, oficjalnego dodatku Keras, do wykonywania PositionEmbedding i TokenAndPositionEmbedding.

KerasNLP

KerasNLP to horyzontalny dodatek do NLP. W chwili pisania jest wciąż bardzo młody, w wersji 0.3, a dokumentacja jest nadal dość krótka, ale pakiet jest już więcej niż użyteczny.

Zapewnia dostęp do warstw Keras, takich jak TokenAndPositionEmbedding, TransformerEncoder i TransformerDecoder, co sprawia, że ​​budowanie niestandardowych transformatorów jest łatwiejsze niż kiedykolwiek.

Aby korzystać z KerasNLP w naszym projekcie, możesz zainstalować go przez pip:

$ pip install keras_nlp

Po zaimportowaniu do projektu możesz użyć dowolnego keras_nlp warstwa jako standardowa warstwa Keras.

tokenizacja

Komputery pracują z liczbami. Wyrażamy nasze myśli słowami. Aby komputer mógł je przebić, musimy w jakiejś formie odwzorować słowa na liczby.

Typowym sposobem na to jest po prostu mapowanie słów na liczby, gdzie każda liczba całkowita reprezentuje słowo. Korpus słów tworzy słownik, a każde słowo w słowniku otrzymuje indeks. W ten sposób możesz przekształcić sekwencję słów w sekwencję indeksów znaną jako tokeny:

def tokenize(sequence):
    
    return tokenized_sequence

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

Ta sekwencja tokenów może być następnie osadzona w gęstym wektorze, który definiuje tokeny w przestrzeni utajonej:

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

Zwykle robi się to za pomocą Embedding warstwa Keras. Transformatory nie kodują tylko za pomocą standardu Embedding warstwa. Wykonują Embedding i PositionEmbedding, i dodaj je do siebie, zastępując regularne osadzenia przez ich położenie w przestrzeni utajonej.

Z KerasNLP – występy TokenAndPositionEmbedding łączy zwykłe osadzanie tokenów (Embedding) z osadzaniem pozycyjnym (PositionEmbedding).

Pozycja Osadzanie

Rzućmy okiem na PositionEmbedding pierwszy. Akceptuje tensory i tensory postrzępione i zakłada, że ​​ostateczny wymiar reprezentuje cechy, podczas gdy przedostatni wymiar reprezentuje sekwencję.

# Seq
(5, 10)
     # Features

Warstwa akceptuje sequence_length argument, oznaczający, no cóż, długość sekwencji wejściowej i wyjściowej. Przejdźmy dalej i osadźmy pozycyjnie losowy jednolity 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)

To skutkuje:

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

Osadzanie tokenów i pozycji

Osadzanie tokenów i pozycji sprowadza się do użycia Embedding w sekwencji wejściowej, PositionEmbedding na osadzonych tokenach, a następnie zsumowanie tych dwóch wyników, skutecznie przesuwając osadzania tokenów w przestrzeni, aby zakodować ich względne znaczące relacje.

Technicznie można to zrobić jako:

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 

Dane wejściowe są osadzane, a następnie osadzane pozycyjnie, po czym są dodawane do siebie, tworząc nowy kształt osadzony pozycyjnie. Alternatywnie możesz wykorzystać TokenAndPositionEmbedding warstwa, która robi to pod kapturem:

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

Dzięki temu jest znacznie czystszy do wykonania 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 

Dane, które przekazaliśmy do warstwy, są teraz pozycyjnie osadzone w ukrytej przestrzeni 10 wymiarów:

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

Idąc dalej – ręczny projekt end-to-end

Twoja dociekliwość sprawia, że ​​chcesz iść dalej? Zalecamy sprawdzenie naszego Projekt z przewodnikiem: „Podpisy obrazów z CNN i transformatorami z Kerasem”.

W tym projekcie z przewodnikiem dowiesz się, jak zbudować model podpisów graficznych, który akceptuje obraz jako dane wejściowe i tworzy podpis tekstowy jako wynik.

Dowiesz się, jak:

• Wstępnie przetwórz tekst
• Łatwo wektoryzuj wprowadzanie tekstu
• Pracuj z tf.data API i kompiluj wydajne zbiory danych
• Buduj transformatory od podstaw z TensorFlow/Keras i KerasNLP – oficjalnym horyzontalnym dodatkiem do Keras do budowania najnowocześniejszych modeli NLP
• Twórz architektury hybrydowe, w których dane wyjściowe z jednej sieci są kodowane dla innej

Jak oprawiamy napisy do obrazów? Większość uważa to za przykład generatywnego uczenia głębokiego, ponieważ uczymy sieć generowania opisów. Lubię jednak patrzeć na to jako na przykład neuronowego tłumaczenia maszynowego – tłumaczymy wizualne cechy obrazu na słowa. Poprzez tłumaczenie generujemy nową reprezentację tego obrazu, a nie tylko nowe znaczenie. Postrzeganie go jako tłumaczenia i tylko przez generowanie rozszerzenia, rzuca zadanie w innym świetle i czyni je nieco bardziej intuicyjnym.

Ujęcie problemu jako tłumaczenia ułatwia ustalenie, z której architektury będziemy chcieli skorzystać. Transformatory tylko z koderem świetnie radzą sobie z rozumieniem tekstu (analiza nastrojów, klasyfikacja itp.), ponieważ kodery kodują znaczące reprezentacje. Modele tylko z dekoderem są świetne do generowania (takie jak GPT-3), ponieważ dekodery są w stanie wywnioskować sensowne reprezentacje w innej sekwencji o tym samym znaczeniu. Tłumaczenie jest zwykle wykonywane przez architekturę kodera-dekodera, gdzie kodery kodują sensowną reprezentację zdania (lub w naszym przypadku obraz), a dekodery uczą się przekształcać tę sekwencję w inną sensowną reprezentację, która jest dla nas bardziej zrozumiała (na przykład zdanie).

wnioski

Transformatory zrobiły wielką falę od 2017 roku, a wiele świetnych przewodników oferuje wgląd w ich działanie, jednak wciąż były one nieuchwytne dla wielu z powodu narzutów na niestandardowe implementacje. KerasNLP rozwiązuje ten problem, dostarczając bloki konstrukcyjne, które pozwalają budować elastyczne, wydajne systemy NLP, zamiast dostarczać gotowe rozwiązania.

W tym przewodniku przyjrzeliśmy się osadzaniu tokenów i pozycji w Keras i KerasNLP.