BERT-Español¶

Explorando modelos pre-entrenados

Autores¶

Alvaro Mauricio Montenegro Díaz, ammontenegrod@unal.edu.co
Daniel Mauricio Montenegro Reyes, dextronomo@gmail.com

Diseño gráfico y Marketing digital¶

Maria del Pilar Montenegro Reyes, pmontenegro88@gmail.com

Asistentes¶

Referencias¶

Contenido¶

Introducción
Extracción de incrustamientos de un modelo BERT pre-entrenado

Introducción¶

Usaremos la implementación de HuggingFace in en Pytorch.

BERT es un modelo con incrustaciones de posición absoluta, por lo que generalmente se recomienda rellenar (padding) las entradas a la derecha en lugar de a la izquierda.
BERT fue entrenado con el modelado de lenguaje enmascarado (MLM) y los objetivos de predicción de la siguiente oración (NSP). Es eficiente para predecir tokens enmascarados y en NLU en general, pero no es óptimo para la generación de texto.

Extracción de incrustamientos de un modelo BERT pre-entrenado¶

La tarea de PLN es análisis de sentimiento. El primer experimento lo hacemos en Español. Para esta tarea esta bién usar el modelo uncase (eliminando mayúsculas).

In [1]:

from transformers import BertModel, BertTokenizer
import torch

Cargamos el modelo pre-entrenado 'bert-base-uncase' y su respectivo tokenizador¶

In [2]:

model = BertModel.from_pretrained('dccuchile/bert-base-spanish-wwm-uncased')
                                 
tokenizer = BertTokenizer.from_pretrained('dccuchile/bert-base-spanish-wwm-uncased')

Downloading:   0%|          | 0.00/650 [00:00<?, ?B/s]

Downloading:   0%|          | 0.00/440M [00:00<?, ?B/s]

Some weights of the model checkpoint at dccuchile/bert-base-spanish-wwm-uncased were not used when initializing BertModel: ['cls.predictions.transform.LayerNorm.bias', 'cls.predictions.transform.dense.weight', 'cls.predictions.transform.LayerNorm.weight', 'cls.predictions.bias', 'cls.predictions.decoder.weight', 'cls.predictions.transform.dense.bias', 'cls.predictions.decoder.bias']
- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).
- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).
Some weights of BertModel were not initialized from the model checkpoint at dccuchile/bert-base-spanish-wwm-uncased and are newly initialized: ['bert.pooler.dense.weight', 'bert.pooler.dense.bias']
You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.

Downloading:   0%|          | 0.00/248k [00:00<?, ?B/s]

Downloading:   0%|          | 0.00/134 [00:00<?, ?B/s]

Downloading:   0%|          | 0.00/310 [00:00<?, ?B/s]

Downloading:   0%|          | 0.00/486k [00:00<?, ?B/s]

Preprocesamiento de la entrada¶

In [3]:

# sentencia
sentence = 'Yo amo a Bogotá'

# tokenización
tokens = tokenizer.tokenize(sentence)

# print
print(tokens)

['yo', 'amo', 'a', 'bogotá']

Agregamos los tokens [CLS] al comienzo y [SEP] al final de la lista de tokens¶

In [4]:

tokens = ['[CLS]'] + tokens + ['[SEP]']

print(tokens)

['[CLS]', 'yo', 'amo', 'a', 'bogotá', '[SEP]']

Relleno y máscara para la sentencia¶

El tamaño de la lista de tokens es 5. Supongamos que hemos decidido que el tamaño máximo se las sentencias será 7. BERT está constuido para aceptar sentencias hasta de tamaño 512. Todas las sentencias deben tener el mismo tamaño.

In [5]:

## Relleno
max_sentence_size = 7
pad_size = max_sentence_size - len(tokens)

for i in range(pad_size): 
    tokens = tokens + ['[PAD]'] 

print(tokens)

['[CLS]', 'yo', 'amo', 'a', 'bogotá', '[SEP]', '[PAD]']

In [6]:

## máscara de atención
attention_mask = [1 if i!= '[PAD]' else 0 for i in tokens]
print(attention_mask)

[1, 1, 1, 1, 1, 1, 0]

Convertimos la lsita de tokens en la lista de ID de los tokens¶

In [7]:

token_ids = tokenizer.convert_tokens_to_ids(tokens)
print(token_ids)

[4, 1252, 4017, 1012, 14548, 5, 1]

Convertimos token_ids y attention_mask a tensores¶

In [8]:

token_ids = torch.tensor(token_ids).unsqueeze(0) # unsuezze es para agregar una dimensión al comienzo (varias sentencias)
attention_mask = torch.tensor(attention_mask).unsqueeze(0)
print(token_ids) # tensor([[ 101, 1045, 2293, 3000,  102,    0,    0]])

tensor([[    4,  1252,  4017,  1012, 14548,     5,     1]])

In [9]:

print(token_ids)
print(attention_mask)

tensor([[    4,  1252,  4017,  1012, 14548,     5,     1]])
tensor([[1, 1, 1, 1, 1, 1, 0]])

Pregunta¶

In [ ]:

¿Cómo hace esto con tensorflow?

Extracción del incrustamiento final¶

model regresa una lista con dos objetos:

El primer valor, last_hidden_state, contiene la representación de todos los tokens obtenidos solo de la capa del codificador final (codificador 12).
A continuación, pooler_output indica la representación del token [CLS] de la capa codificadora final, que se procesa posteriormente mediante una capa lineal y una activación tanh. La capa lineal es entrenada cuando se entrena el modelo BERT para la tarea NSP (Next sequence prediction).

In [10]:

out = model(token_ids, attention_mask = attention_mask)
last_hidden_state, pooler_output = out.last_hidden_state, out.pooler_output # out[0], out[1]

In [11]:

print(last_hidden_state.shape)

torch.Size([1, 7, 768])

Tamaño batch = 1
Tamaño secuencia = 7
tamaño del emebdding = 768

In [12]:

# out es un diccionario. Podemos obtener las claves  así:
out.keys()

Out[12]:

odict_keys(['last_hidden_state', 'pooler_output'])

Extracción de los incrustamientos de todas las capas codificadoras¶

En esta sección revisamos como extraer las incrustaciones (embeddings) que salen de cada una de las capas codificadoras (12 por ejemplo en el modelo base). Algunos veces estop se hace para extraer diferentes features de las sentencias.

Por ejemplo en la tarea NER (name entity recognition) los investigadores han usado las incrustaciones de las diferentes capas, para hacr promedios pesados de algunas de ellas y con esto han podido mejorar la exactitud en la precisión.

Para hacer esto, es necesario instanciar el modelo preentrenado con la opción output_hidden_states=True:

In [ ]:

model = BertModel.from_pretrained('dccuchile/bert-base-spanish-wwm-uncased', output_hidden_states=True)
tokenizer = BertTokenizer.from_pretrained('dccuchile/bert-base-spanish-wwm-uncased')

In [14]:

out = model(token_ids, attention_mask=attention_mask)

last_hidden_state, pooler_output, hidden_states = \
        out.last_hidden_state, out.pooler_output, out.hidden_states

In [15]:

print(last_hidden_state.shape)
print(pooler_output.shape)
print(len(hidden_states)) # esta es una lista conteniendo las
                          # incrutaciones de todas las capas codificadoras

torch.Size([1, 7, 768])
torch.Size([1, 768])
13

Observe que hidden_states tiene 13 elementos. La capa 0 corresponde a la incrustación de la capa de entrada, luego los elementos 1 a 12 corresponden a las incrustaciones de de salida de cada una de las 12 capas codificadoras.

La representación de los token de la última capa oculta (codificadora) pueden ser obtenidos así:

last_hidden_state[0][0]: entrega la representación del prime token, es decir, [CLS].
last_hidden_state[0][1]: entrega la representación del Token I.
last_hidden_state[0][2]: entrega la representación del Token love.

Esta es la representación contextual final de los token.

Las incrustaciones de cada capa i, se obtienen mediante *hidden_states[i]:

In [16]:

# Incrutaciones de la capa de entrada
input_embedding = hidden_states[0]
print(input_embedding.shape)

# incrustaciones de la capa codificadora 11
embedding_11 = hidden_states[11]
print(embedding_11.shape)

torch.Size([1, 7, 768])
torch.Size([1, 7, 768])

In [ ]:

help(out)

Recuperando los pesos de atención¶

Los pesos de atención después de la atención softmax, se utilizan para calcular el promedio ponderado en las cabezas de autoatención. Son obtenidos pasando al modelo output_attentions=True

output attention es una tupla. Cada elemento coresponde a los pesos de atención de cada capa codificadora.

In [ ]:

model = BertModel.from_pretrained('dccuchile/bert-base-spanish-wwm-uncased',\
                                  output_hidden_states=True, output_attentions=True)
tokenizer = BertTokenizer.from_pretrained('dccuchile/bert-base-spanish-wwm-uncased')

In [20]:

out = model(token_ids, attention_mask=attention_mask)

last_hidden_state, pooler_output, hidden_states, attentions = \
        out.last_hidden_state, out.pooler_output, out.hidden_states, \
        out.attentions
print(len(attentions))

In [21]:

print(attentions[11].shape)

torch.Size([1, 12, 7, 7])

La salida se explica así:

El tamaño del batch es 1. Una sentencia.
Son 12 cabezas de atención.
La sentencia viene de tamaño 7.

Por lo tanto tenemos la salida de las 12 cabezas de atención para la sentencia.

Vamos a darle una mirada a los pesos de atención de la última capa codificadora

In [22]:

attention11 = attentions[11].squeeze()#elimina la dimensión de batch.

In [23]:

attention11.shape

Out[23]:

torch.Size([12, 7, 7])

Función para graficar pesos de atención de una cabeza¶

In [24]:

import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1 import make_axes_locatable

# versión con decode utf-8
def plot_attention_head_cp(in_tokens, translated_tokens, attention):
  # The plot is of the attention when a token was generated.
  # The model didn't generate `<START>` in the output. Skip it.
  translated_tokens = translated_tokens[1:]

  ax = plt.gca()
  ax.matshow(attention)
  ax.set_xticks(range(len(in_tokens)))
  ax.set_yticks(range(len(translated_tokens)))

  labels = [label.decode('utf-8') for label in in_tokens.numpy()]
  ax.set_xticklabels(
      labels, rotation=90)

  labels = [label.decode('utf-8') for label in translated_tokens.numpy()]
  ax.set_yticklabels(labels)



def plot_attention_head(in_tokens, translated_tokens, attention):
  # The plot is of the attention when a token was generated.
  # The model didn't generate `<START>` in the output. Skip it.
  #translated_tokens = translated_tokens[1:]

  ax = plt.gca()
  pcm = ax.matshow(attention)
  ax.set_xticks(range(len(in_tokens)))
  ax.set_yticks(range(len(translated_tokens)))

  labels = [label for label in in_tokens]
  ax.set_xticklabels(
      labels, rotation=90)

  labels = [label for label in translated_tokens]
  ax.set_yticklabels(labels)
  
 

In [25]:

head = attention11[0]
head.shape

Out[25]:

torch.Size([7, 7])

In [26]:

head = head.detach().numpy()

In [27]:

plot_attention_head(in_tokens=tokens, translated_tokens=tokens, attention=head)

Visualizando los pesos de todas las cabezas de atención¶

In [28]:

def plot_attention_weights(sentence, translated_tokens, attention_heads):
  in_tokens = sentence
  #in_tokens = tokenizers.pt.tokenize(in_tokens).to_tensor()
  #in_tokens = tokenizers.pt.lookup(in_tokens)[0]
  #in_tokens

  fig = plt.figure(figsize=(16, 8))

  for h, head in enumerate(attention_heads):
    ax = fig.add_subplot(3, 4, h+1)

    plot_attention_head(in_tokens, translated_tokens, head)

    ax.set_xlabel(f'Head {h+1}')

  plt.tight_layout()
  plt.show()

In [29]:

heads = attention11.detach().numpy()

plot_attention_weights(sentence=tokens, translated_tokens=tokens, 
                      attention_heads=heads)

In [ ]: