Token Transformer e inclusione della posizione con Keras

Introduzione

Esistono numerose guide che spiegano come funzionano i trasformatori e per costruire un'intuizione su un loro elemento chiave: l'incorporamento di token e posizioni.

L'incorporamento posizionale dei token ha consentito ai trasformatori di rappresentare relazioni non rigide tra i token (di solito, parole), il che è molto migliore nel modellare il nostro discorso guidato dal contesto nella modellazione linguistica. Sebbene il processo sia relativamente semplice, è abbastanza generico e le implementazioni diventano rapidamente standard.

In questa breve guida, daremo un'occhiata a come possiamo utilizzare KerasNLP, il componente aggiuntivo ufficiale di Keras, per eseguire PositionEmbedding ed TokenAndPositionEmbedding.

Keras NLP

KerasNLP è un'aggiunta orizzontale alla PNL. Al momento della stesura, è ancora molto giovane, alla versione 0.3, e la documentazione è ancora abbastanza breve, ma il pacchetto è già più che utilizzabile.

Fornisce l'accesso ai livelli Keras, come TokenAndPositionEmbedding, TransformerEncoder ed TransformerDecoder, il che rende la costruzione di trasformatori personalizzati più semplice che mai.

Per utilizzare KerasNLP nel nostro progetto, è possibile installarlo tramite pip:

$ pip install keras_nlp

Una volta importato nel progetto, è possibile utilizzarne uno qualsiasi keras_nlp livello come livello Keras standard.

tokenizzazione

I computer funzionano con i numeri. Esprimiamo i nostri pensieri in parole. Per consentire al computer di analizzarli, dovremo associare le parole ai numeri in qualche modo.

Un modo comune per farlo è semplicemente associare le parole ai numeri in cui ciascun numero intero rappresenta una parola. Un corpus di parole crea un vocabolario e ogni parola del vocabolario ottiene un indice. Pertanto, puoi trasformare una sequenza di parole in una sequenza di indici nota come token:

def tokenize(sequence):
    
    return tokenized_sequence

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

Questa sequenza di token può quindi essere incorporata in un vettore denso che definisce i token nello spazio latente:

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

Questo viene in genere fatto con il Embedding strato di Keras. I trasformatori non codificano solo utilizzando uno standard Embedding strato. Si esibiscono Embedding ed PositionEmbedding, e sommarli insieme, spostando gli incastri regolari in base alla loro posizione nello spazio latente.

Con KerasNLP – performante TokenAndPositionEmbedding combina l'incorporamento regolare di token (Embedding) con incorporamento posizionale (PositionEmbedding).

PosizioneEmbedding

Diamo uno sguardo a PositionEmbedding Primo. Accetta tensori e tensori irregolari e presuppone che la dimensione finale rappresenti le caratteristiche, mentre la penultima dimensione rappresenti la sequenza.

# Seq
(5, 10)
     # Features

Il livello accetta a sequence_length argomento, che denota, beh, la lunghezza della sequenza di input e output. Andiamo avanti e incorporiamo posizionalmente un tensore uniforme casuale:

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)

Questo risulta in:

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

Incorporamento di tokenandposizione

L'incorporamento di token e posizioni si riduce all'utilizzo Embedding sulla sequenza di input, PositionEmbedding sui token incorporati, e quindi sommando questi due risultati insieme, spostando effettivamente gli incorporamenti dei token nello spazio per codificare le loro relative relazioni significative.

Questo può tecnicamente essere fatto come:

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 

Gli input vengono incorporati, quindi incorporati posizionalmente, dopodiché vengono sommati insieme, producendo una nuova forma incorporata posizionalmente. In alternativa, puoi sfruttare il TokenAndPositionEmbedding layer, che fa questo sotto il cofano:

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

Ciò rende l'esecuzione molto più pulita 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 

I dati che abbiamo passato al livello sono ora incorporati posizionalmente in uno spazio latente di 10 dimensioni:

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

Andare oltre – Progetto end-to-end manuale

La tua natura curiosa ti fa venire voglia di andare oltre? Ti consigliamo di dare un'occhiata al nostro Progetto guidato: "Sottotitoli di immagini con CNN e Transformers con Keras".

In questo progetto guidato imparerai come costruire un modello di didascalia delle immagini, che accetta un'immagine come input e produce una didascalia testuale come output.

Imparerete a:

• Preelaborare il testo
• Vettorializza facilmente l'input di testo
• Lavora con tf.data API e crea set di dati performanti
• Costruisci Transformers da zero con TensorFlow/Keras e KerasNLP: l'aggiunta orizzontale ufficiale a Keras per la creazione di modelli NLP all'avanguardia
• Costruisci architetture ibride in cui l'output di una rete è codificato per un'altra

Come inquadriamo i sottotitoli delle immagini? Molti lo considerano un esempio di deep learning generativo, perché stiamo insegnando a una rete a generare descrizioni. Tuttavia, mi piace considerarlo un esempio di traduzione automatica neurale: stiamo traducendo in parole le caratteristiche visive di un’immagine. Attraverso la traduzione, stiamo generando una nuova rappresentazione di quell’immagine, invece di generare semplicemente un nuovo significato. Considerarlo come una traduzione e solo tramite la generazione di estensioni, analizza l'attività sotto una luce diversa e la rende un po' più intuitiva.

Inquadrare il problema come problema di traduzione rende più semplice capire quale architettura vorremo utilizzare. I trasformatori solo codificatori sono ottimi per comprendere il testo (analisi del sentiment, classificazione, ecc.) perché i codificatori codificano rappresentazioni significative. I modelli solo decodificatori sono ottimi per la generazione (come GPT-3), poiché i decodificatori sono in grado di dedurre rappresentazioni significative in un'altra sequenza con lo stesso significato. La traduzione viene generalmente eseguita da un'architettura codificatore-decodificatore, dove i codificatori codificano una rappresentazione significativa di una frase (o un'immagine, nel nostro caso) e i decodificatori imparano a trasformare questa sequenza in un'altra rappresentazione significativa che sia più interpretabile per noi (come una frase).

Conclusioni

I Transformer hanno avuto un grande successo a partire dal 2017 e molte ottime guide offrono informazioni su come funzionano, ma per molti erano ancora sfuggenti a causa del sovraccarico delle implementazioni personalizzate. KerasNLP affronta questo problema, fornendo elementi costitutivi che consentono di creare sistemi PNL flessibili e potenti, anziché fornire soluzioni preconfezionate.

In questa guida, abbiamo dato un'occhiata all'incorporamento di token e posizioni con Keras e KerasNLP.