GPT-2 es un modelo de lenguaje artificial creado por OpenAI en 2019. Las siglas vienen de Generative Pre-trained Transformer o, en español, transformador preentrenado generativo.

En este artículo, veremos un poco cuáles son los aspectos a tener en cuenta cuando trabajamos con GPT-2.

¿Qué encontrarás en este post?

¿Qué es GPT-2?

GPT-2 es un modelo de deep learning entrenado con grandes corpus de texto, con la finalidad de predecir palabras o secuencias de palabras en un texto. Puede generar texto coherente y de una calidad intachable en muchísimas áreas de interés y es, de hecho, uno de los modelos y algoritmos de lenguaje artificial más sofisticados actualmente.

Su uso se extiende a una amplia gama de aplicaciones, entre ellas las aplicaciones de generación de texto, el modelado de lenguaje natural, la traducción automática y la respuesta automática a preguntas, entre otras tantas funcionalidades. No obstante, debido a su gran capacidad para generar texto, esto puede tender a la infoxicación e, incluso, a las fake news.

Funcionamiento de GPT-2

GPT-2 utiliza un enfoque llamado transformador para procesar el lenguaje natural. El transformador es una arquitectura de red neuronal que se basa en la idea de que las palabras en una oración no tienen un significado aislado, sino que dependen del contexto que las rodea. Por lo tanto, el transformador tiene en cuenta todo el contexto de la oración, incluyendo las palabras que la preceden y las que la siguen, para predecir la siguiente palabra o secuencia de palabras en un texto.

El modelo se entrena en un gran corpus de texto empleando un proceso llamado aprendizaje self attention. Durante el entrenamiento, el modelo aprende a predecir la siguiente palabra en una secuencia de texto dada la secuencia anterior. A medida que se entrena, el modelo aprende patrones en el lenguaje que puede usar para generar texto coherente y de alta calidad.

Una vez que se ha entrenado, el modelo se puede utilizar para generar texto de manera similar a como lo haría un ser humano. El modelo recibe una secuencia de entrada y usa sus conocimientos sobre el lenguaje natural para generar una secuencia de salida, que sigue las convenciones lingüísticas y gramaticales.

GPT-2 emplea una técnica llamada aprendizaje por atención para asegurarse de que el modelo preste más atención a las partes relevantes de la secuencia de entrada. El aprendizaje por atención permite que el modelo se centre en las palabras más importantes en el contexto, lo que ayuda a mejorar la calidad de la salida generada.

En general, el proceso de funcionamiento de GPT-2 se puede resumir en tres pasos principales: entrada de texto, procesamiento de texto empleando la arquitectura de transformadores y salida de texto generado.

Dimensiones de los modelos

Las dimensiones de los modelos de GPT-2 dependen de cada uno de los decodificadores que tengan.

Vemos que el más pequeño de GPT-2 tiene 12 decodificadores, mientras que el más grande tiene 48 decodificadores.

Outputs o salidas de los modelos GPT-2

Al igual que otros modelos, GPT-2 produce salidas por palabras. Es decir, saca una a una las palabras, no saca todas las predicciones de golpe:

The decoder block

En la parte del transformer, el self attention estaba incluido entre medias y era normal en cada parte del encoder y el decoder. Esto miraba cada una de las palabras por delante y por detrás. En GPT-2 se introduce otro tipo de atención que es el masked self-attention.

Ejercicio sobre modelo GPT-2

Lo primero que haremos será instalar la librería:

! pip install --force - reinstall transformers [tf - cpu] tensorflow == 2.7.0

Luego importaremos el modelo que vamos a utilizar:

#Ejercicio sobre modelo GPT-2
from transformers import (
          GPT2Tokenizer,
          DataCollatorForLanguageModeling,
          TextDataset,
          GPT2LMHeadModel,
          TrainingArguments,
          Trainer,
          pipeline)

Aquí hay una diferencia respecto a los otros modelos que hemos usado hasta ahora, ya que antes de hacer el modelo hemos generado un tokenizador, como puede ser NLTK, y también hemos hecho una limpieza de los datos. Esto, con el uso de GPT-2, no tenemos que hacerlo, dado que aquí no solo nos dan un modelo, sino que además tenemos un tokenizador ya entrenado con los mismos datos que GPT-2 para un uso magnífico del corpus que tengamos.

Al final, GPT-2 está entrenado con un corpus enorme, lo que nos reduce muchísimo el trabajo.

Descargamos el preentrenado del tokenizador:

#Ejercicio sobre modelo GPT-2
tokenizer = GPT2Tokenizer.from_pretrained ("gpt2")

#Ejercicio sobre modelo GPT-2
print ('vocabulary size: %d, max squence length: %d' % (tokenizer.vocab_size, tokenizer.model_max_length))
print ('tokenize sequence "Once upon a time in a little village": ', tokenizer ('Once upon a time in a little village'))

Este modelo nos ha traducido el cuento a los identificadores dentro de su vocabulario, los correspondientes a cada uno de los tokens.

Ahora le decimos que para hacer el modelado vamos a utilizar el tokenizador de GPT-2:

#Ejercicio sobre modelo GPT-2
data_collator = DataCollatorForLanguageModeling (tokenizer = tokenizer, mlm = False)

Vamos a utilizar los mismos datos de entrenamiento y de test y nos va a separar en secuencias de 128 palabras:

#Ejercicio sobre modelo GPT-2
train_dataset = TextDataset (
       tokenizer = tokenizer,
       file_path = "merged_clean.txt",
       block_size = 128)

test_dataset = TextDataset (
       tokenizer = tokenizer,
       file_path = "merged_clean.txt",
       block_size = 128)

Cuando nos devuelve el train dataset, ya nos lo entrega tokenizado, por tanto, si queremos ver el dato original, lo que tenemos que hacer es un decode con un tokenizer.decode. Después le decimos cuál es el ejemplo de entrenamiento que queremos trabajar:

#Ejercicio sobre modelo GPT-2
print (tokenizer.decode (train_dataset [5]))

El modelo

El modelo que usaremos será el GPT2LMHeadModel, al que llamamos e invocamos el método de from_pretrained. Descargamos el modelo:

#Ejercicio sobre modelo GPT-2
model = GPT2LMHeadModel.from_pretrained ('gpt2')

Ahora establecemos los parámetros de entrenamiento:

#Ejercicio sobre modelo GPT-2
training_args = TrainingArguments (
       output_dir = 'data / out', #the output directory for the model predictions and checkpoints
       overwrite_output_dir = True, #overwrite the content of the output directory
       per_device_train _batch_size = 4, #the batch size for training
       per_device_eval _batch_size = 4, #the batch size for evaluation
      learning_rate = 5e - 5, #defaults to 5e - 5
      num_train_epochs = 1, #total number of training epochs to perform
)

trainer = Trainer (
      model = model,
      args = training_args,
      data_collator = data_collator,
      train_dataset = train_dataset,
      eval_dataset = test_dataset
)

Los checkpoint son como puntos de guardado entre medias, hasta que finalice la ejecución del modelo.

#Ejercicio sobre modelo GPT-2
import torch

torch.cuda.empty_cache ()

Ahora entrenamos:

#Ejercicio sobre modelo GPT-2
trainer.train ()

#Ejercicio sobre modelo GPT-2
trainer.save _model ()

Ahora importamos el pipeline, que nos permite definir qué tarea vamos a hacer y, con base en eso, el modelo hará lo que le pedimos:

#Ejercicio sobre modelo GPT-2
generator = pipeline ('text - generation', tokenizer = 'gpt2', model = 'data / out')

Veamos un pequeño ejemplo de cómo quedaría el resultado:

#Ejercicio sobre modelo GPT-2
print (generator ('There is a building', max_length = 500) [0] ['generated_text'])

#Ejercicio sobre modelo GPT-2
from transformers import AutoTokenizer, AutoModelForCausalLM
tokenizer = AutoTokenizer.from :_pretrained ("DeepESP 7 gpt2 - spanish")
model = AutoModelForCausalLM.from_pretrained ("DeepESP / gpt2 - spanish")

#Ejercicio sobre modelo GPT-2
generator = pipeline ('text - generation', tokenizer = 'DeepESP / gpt2 - spanish', model = 'DeepESP / gpt2 - spanish')

Ahora que sabes un poco más acerca de GPT-2, es el momento de seguir formándote en alguna de las numerosas temáticas que tiene el ámbito del Big Data, una de las áreas más demandadas y mejor pagadas del mundo. En KeepCoding te ofrecemos la posibilidad de aprender con los mejores profesionales, que te guiarán a través de los conocimientos teóricos y prácticos para que, en pocos meses, te conviertas en un gran profesional IT. Revisa el temario de nuestro Big Data, Inteligencia Artificial & Machine Learning Full Stack Bootcamp y descubre esta formación intensiva de alta calidad. ¡Solicita ahora más información y da el paso que impulsará tu carrera!