En este artículo realizaremos un ejercicio sobre modelo GPT-2, que nos permitirá entender mejor su funcionamiento.

En un artículo pasado hablamos sobre el funcionamiento de GPT-2. Dijimos que es un modelo de deep learning entrenado con grandes corpus de texto, con el objetivo de predecir palabras o secuencias de palabras en un texto. Puede generar texto coherente y de gran calidad en muchísimas áreas de interés. De hecho, se trata de uno de los modelos y algoritmos de lenguaje artificial más sofisticados de la actualidad.

¿Qué encontrarás en este post?

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

¿Qué sigue?

Ahora que hemos realizado este ejercicio sobre modelo GPT-2, es el momento perfecto para seguir formándote en alguna de las numerosas temáticas que tiene el ámbito del Big Data. En KeepCoding podrás aprender con la guía de los mejores profesionales, que te acompañarán a través de la teoría y la práctica para convertirte en un gran profesional IT en poco tiempo. Échale un vistazo a nuestro Big Data, Inteligencia Artificial & Machine Learning Full Stack Bootcamp y no te pierdas esta formación íntegra e intensiva de alta calidad. ¡Solicita ya más información y da el paso que te cambiará la vida!