Token de transformador e incrustación de posición con Keras

Introducción

Hay muchas guías que explican cómo funcionan los transformadores y cómo construir una intuición sobre un elemento clave de ellos: la incorporación de fichas y posiciones.

Los tokens incorporados posicionalmente permitieron a los transformadores representar relaciones no rígidas entre tokens (generalmente, palabras), lo que es mucho mejor para modelar nuestro discurso basado en el contexto en el modelado de lenguaje. Si bien el proceso es relativamente simple, es bastante genérico y las implementaciones se convierten rápidamente en estándar.

En esta breve guía, veremos cómo podemos usar KerasNLP, el complemento oficial de Keras, para realizar PositionEmbedding y TokenAndPositionEmbedding.

Keras PNL

KerasNLP es una adición horizontal para NLP. Al momento de escribir, todavía es muy joven, en la versión 0.3, y la documentación aún es bastante breve, pero el paquete ya es más que utilizable.

Proporciona acceso a las capas de Keras, como TokenAndPositionEmbedding, TransformerEncoder y TransformerDecoder, lo que hace que la construcción de transformadores personalizados sea más fácil que nunca.

Para usar KerasNLP en nuestro proyecto, puede instalarlo a través de pip:

$ pip install keras_nlp

Una vez importado al proyecto, puede usar cualquier keras_nlp capa como una capa estándar de Keras.

Tokenization

Las computadoras trabajan con números. Expresamos nuestros pensamientos en palabras. Para permitir que la computadora los analice, tendremos que asignar palabras a números de alguna forma.

Una forma común de hacer esto es simplemente asignar palabras a números donde cada número entero representa una palabra. Un corpus de palabras crea un vocabulario, y cada palabra del vocabulario obtiene un índice. Por lo tanto, puede convertir una secuencia de palabras en una secuencia de índices conocida como fichas:

def tokenize(sequence):
    
    return tokenized_sequence

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

Esta secuencia de tokens se puede incrustar en un vector denso que define los tokens en el espacio latente:

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

Esto normalmente se hace con el Embedding capa en Keras. Los transformadores no codifican solo usando un estándar Embedding capa. Ellos realizan Embedding y PositionEmbedding, y súmalos, desplazando las incrustaciones regulares por su posición en el espacio latente.

Con KerasNLP: actuación TokenAndPositionEmbedding combina la incrustación de token regular (Embedding) con incrustación posicional (PositionEmbedding).

PosiciónIncrustación

Echemos un vistazo a PositionEmbedding primero. Acepta tensores y tensores irregulares, y asume que la dimensión final representa las características, mientras que la penúltima dimensión representa la secuencia.

# Seq
(5, 10)
     # Features

La capa acepta una sequence_length argumento, que denota, bueno, la longitud de la secuencia de entrada y salida. Avancemos e incrustemos posicionalmente un tensor uniforme aleatorio:

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)

Esto resulta en:

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

Incrustación de token y posición

La incrustación de tokens y posiciones se reduce a usar Embedding en la secuencia de entrada, PositionEmbedding en los tokens incrustados, y luego sumando estos dos resultados, desplazando efectivamente las incrustaciones de tokens en el espacio para codificar sus relaciones significativas relativas.

Esto se puede hacer técnicamente como:

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 

Las entradas se incrustan y luego se incrustan posicionalmente, después de lo cual se suman, produciendo una nueva forma incrustada posicionalmente. Alternativamente, puede aprovechar la TokenAndPositionEmbedding capa, que hace esto bajo el capó:

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

Esto hace que sea mucho más limpio de realizar. 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 

Los datos que hemos pasado a la capa ahora están incrustados posicionalmente en un espacio latente de 10 dimensiones:

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

Yendo más allá: proyecto portátil de extremo a extremo

¿Tu naturaleza inquisitiva te hace querer ir más allá? Recomendamos revisar nuestro Proyecto Guiado: “Subtítulos de imágenes con CNNs y Transformers con Keras”.

En este proyecto guiado, aprenderá a crear un modelo de subtítulos de imágenes, que acepta una imagen como entrada y produce un subtítulo de texto como salida.

Usted aprenderá cómo:

• Preprocesar texto
• Vectorice la entrada de texto fácilmente
• Trabajar con el tf.data API y construir conjuntos de datos de alto rendimiento
• Cree Transformers desde cero con TensorFlow/Keras y KerasNLP, la adición horizontal oficial a Keras para crear modelos NLP de última generación.
• Cree arquitecturas híbridas donde la salida de una red se codifica para otra

¿Cómo enmarcamos los subtítulos de las imágenes? La mayoría lo considera un ejemplo de aprendizaje profundo generativo, porque estamos enseñando a una red a generar descripciones. Sin embargo, me gusta verlo como una instancia de traducción automática neuronal: estamos traduciendo las características visuales de una imagen en palabras. A través de la traducción, estamos generando una nueva representación de esa imagen, en lugar de simplemente generar un nuevo significado. Verlo como traducción, y solo por generación de extensión, enfoca la tarea bajo una luz diferente y la hace un poco más intuitiva.

Enmarcar el problema como uno de traducción hace que sea más fácil determinar qué arquitectura querremos usar. Los transformadores solo de codificador son excelentes para comprender el texto (análisis de opinión, clasificación, etc.) porque los codificadores codifican representaciones significativas. Los modelos de solo decodificador son excelentes para la generación (como GPT-3), ya que los decodificadores pueden inferir representaciones significativas en otra secuencia con el mismo significado. La traducción generalmente se realiza mediante una arquitectura de codificador-decodificador, donde los codificadores codifican una representación significativa de una oración (o imagen, en nuestro caso) y los decodificadores aprenden a convertir esta secuencia en otra representación significativa que es más interpretable para nosotros (como una oración).

Conclusiones

Los transformadores han hecho una gran ola desde 2017, y muchas guías excelentes ofrecen información sobre cómo funcionan, sin embargo, todavía eran esquivos para muchos debido a la sobrecarga de las implementaciones personalizadas. KerasNLP aborda este problema, proporcionando componentes básicos que le permiten crear sistemas NLP potentes y flexibles, en lugar de proporcionar soluciones preempaquetadas.

En esta guía, hemos analizado la incorporación de tokens y posiciones con Keras y KerasNLP.