Token Transformer dan Penyematan Posisi dengan Keras

Pengantar

Ada banyak panduan yang menjelaskan cara kerja transformator, dan untuk membangun intuisi pada elemen kuncinya – penyematan token dan posisi.

Token yang disematkan secara posisi memungkinkan transformer untuk mewakili hubungan yang tidak kaku antara token (biasanya, kata-kata), yang jauh lebih baik dalam memodelkan pidato berbasis konteks kami dalam pemodelan bahasa. Meskipun prosesnya relatif sederhana, ini cukup umum, dan implementasinya dengan cepat menjadi boilerplate.

Dalam panduan singkat ini, kita akan melihat bagaimana kita dapat menggunakan KerasNLP, add-on resmi Keras, untuk melakukan PositionEmbedding dan TokenAndPositionEmbedding.

KerasNLP

KerasNLP adalah tambahan horizontal untuk NLP. Pada saat penulisan, ini masih sangat muda, pada versi 0.3, dan dokumentasinya masih cukup singkat, tetapi paketnya sudah lebih dari sekadar dapat digunakan.

Ini menyediakan akses ke lapisan Keras, seperti TokenAndPositionEmbedding, TransformerEncoder dan TransformerDecoder, yang membuat pembuatan trafo khusus lebih mudah dari sebelumnya.

Untuk menggunakan KerasNLP dalam proyek kami, Anda dapat menginstalnya melalui pip:

$ pip install keras_nlp

Setelah diimpor ke proyek, Anda dapat menggunakan keras_nlp lapisan sebagai lapisan Keras standar.

Tokenisasi

Komputer bekerja dengan angka. Kami menyuarakan pikiran kami dengan kata-kata. Untuk memungkinkan komputer mengolahnya, kita harus memetakan kata ke angka dalam beberapa bentuk.

Cara umum untuk melakukannya adalah dengan hanya memetakan kata ke angka di mana setiap bilangan bulat mewakili sebuah kata. Korpus kata menciptakan kosa kata, dan setiap kata dalam kosa kata mendapat indeks. Dengan demikian, Anda dapat mengubah urutan kata menjadi urutan indeks yang dikenal sebagai token:

def tokenize(sequence):
    
    return tokenized_sequence

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

Urutan token ini kemudian dapat disematkan ke dalam vektor padat yang mendefinisikan token di ruang laten:

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

Ini biasanya dilakukan dengan Embedding lapisan di Keras. Transformer tidak mengkodekan hanya menggunakan standar Embedding lapisan. Mereka tampil Embedding dan PositionEmbedding, dan menambahkannya bersama-sama, menggantikan embeddings biasa dengan posisinya di ruang laten.

Dengan KerasNLP – tampil TokenAndPositionEmbedding menggabungkan penyematan token biasa (Embedding) dengan penyematan posisi (PositionEmbedding).

Penyematan Posisi

Mari kita lihat PositionEmbedding pertama. Ia menerima tensor dan tensor kasar, dan mengasumsikan bahwa dimensi akhir mewakili fitur, sedangkan dimensi kedua hingga terakhir mewakili urutan.

# Seq
(5, 10)
     # Features

Lapisan menerima sequence_length argumen, yang menunjukkan, baik, panjang urutan input dan output. Mari kita lanjutkan dan menyematkan tensor seragam acak secara posisi:

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)

Ini menghasilkan:

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

Penyematan TokenDanPosisi

Penyematan token dan posisi bermuara pada penggunaan Embedding pada urutan masukan, PositionEmbedding pada token yang disematkan, dan kemudian menambahkan kedua hasil ini bersama-sama, secara efektif menggantikan penyematan token di ruang untuk menyandikan hubungan yang relatif bermakna.

Ini secara teknis dapat dilakukan sebagai:

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 

Input disematkan, lalu disematkan secara posisi, setelah itu ditambahkan bersama-sama, menghasilkan bentuk baru yang disematkan secara posisi. Atau, Anda dapat memanfaatkan TokenAndPositionEmbedding lapisan, yang melakukan ini di bawah tenda:

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

Ini membuatnya jauh lebih bersih untuk dilakukan 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 

Data yang telah kita teruskan ke dalam lapisan sekarang secara posisi tertanam dalam ruang laten 10 dimensi:

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

Melangkah Lebih Jauh – Proyek Hand-Held End-to-End

Sifat ingin tahu Anda membuat Anda ingin melangkah lebih jauh? Kami merekomendasikan untuk memeriksa kami Proyek Terpandu: “Teks Gambar dengan CNN dan Transformer dengan Keras”.

Dalam proyek terpandu ini – Anda akan belajar cara membuat model teks gambar, yang menerima gambar sebagai input dan menghasilkan teks teks sebagai output.

Anda akan belajar cara:

• Teks praproses
• Membuat vektor input teks dengan mudah
• Bekerja dengan tf.data API dan bangun Kumpulan Data berkinerja
• Bangun Transformer dari awal dengan TensorFlow/Keras dan KerasNLP – tambahan horizontal resmi untuk Keras untuk membangun model NLP canggih
• Bangun arsitektur hibrida di mana output dari satu jaringan dikodekan untuk yang lain

Bagaimana kita membingkai keterangan gambar? Sebagian besar menganggapnya sebagai contoh pembelajaran mendalam generatif, karena kami mengajarkan jaringan untuk menghasilkan deskripsi. Namun, saya suka melihatnya sebagai contoh terjemahan mesin saraf – kami menerjemahkan fitur visual dari sebuah gambar ke dalam kata-kata. Melalui terjemahan, kami menghasilkan representasi baru dari gambar itu, bukan hanya menghasilkan makna baru. Melihatnya sebagai terjemahan, dan hanya dengan pembuatan ekstensi, cakupan tugas dalam cahaya yang berbeda, dan membuatnya sedikit lebih intuitif.

Membingkai masalah sebagai salah satu terjemahan membuatnya lebih mudah untuk mengetahui arsitektur mana yang ingin kita gunakan. Transformer khusus pembuat enkode sangat bagus dalam memahami teks (analisis sentimen, klasifikasi, dll.) karena Enkoder mengkodekan representasi yang bermakna. Model khusus-dekoder sangat bagus untuk generasi (seperti GPT-3), karena dekoder dapat menyimpulkan representasi yang bermakna ke dalam urutan lain dengan makna yang sama. Terjemahan biasanya dilakukan oleh arsitektur encoder-decoder, di mana pembuat enkode menyandikan representasi kalimat yang bermakna (atau gambar, dalam kasus kami) dan dekoder belajar mengubah urutan ini menjadi representasi bermakna lain yang lebih dapat ditafsirkan bagi kami (seperti kalimat).

Kesimpulan

Transformer telah membuat gelombang besar sejak 2017, dan banyak panduan hebat menawarkan wawasan tentang cara kerjanya, namun, mereka masih sulit dipahami oleh banyak orang karena overhead implementasi kustom. KerasNLP mengatasi masalah ini, menyediakan blok bangunan yang memungkinkan Anda membangun sistem NLP yang fleksibel dan kuat, daripada memberikan solusi yang sudah dikemas sebelumnya.

Dalam panduan ini, kita telah melihat penyematan token dan posisi dengan Keras dan KerasNLP.