La accesibilidad de GPT-2: generación y ajuste de texto

La generación de lenguaje natural (NLG) es un tema bien estudiado entre la comunidad de NLP. Con el auge de los métodos de aprendizaje profundo, NLG se ha vuelto cada vez mejor. Recientemente, OpenAI ha empujado los límites, con el lanzamiento de GPT-2 – a Transformadores modelo basado que predice el siguiente simbólico en cada espacio de tiempo.

Hoy en día es bastante fácil usar estos modelos: no necesita implementar el código usted mismo o entrenar los modelos utilizando recursos costosos. HuggingFace, por ejemplo, tiene lanzó una API que facilita el acceso al GPT-2 preentrenado que OpenAI ha publicado. Algunas de sus características incluyen la generación de texto, así como el ajuste fino del modelo en su propio conjunto de datos, cambiando la distribución aprendida para que el modelo genere texto desde un nuevo dominio.

Hacer todo esto es fácil: solo es cuestión de instalar pip los paquetes relevantes y ejecutar un script de python. Sin embargo, para ahorrarte la molestia, puedes usar una de las plataformas disponibles, como Deletrear – solo especifica lo que desea ejecutar y Spell se encargará del resto (descargar el código, instalar los paquetes, asignar recursos informáticos, administrar los resultados).

Si bien no soy un defensor de Spell (ni siquiera probé otras funciones de la plataforma, ni probé otras plataformas en absoluto), decidí escribir un tutorial que detalla el proceso que acabo de describir. Para saber más, puedes encontrar el tutorial aquí.

Si también te gusta jugar con el texto generado por la máquina, no dudes en dejar un comentario con los textos interesantes que hayas obtenido. 🙂


ACTUALIZAR: parece que el tutorial ya no está disponible en el enlace mencionado. Aunque está un poco desactualizado (la API de la cara abrazada ha cambiado mucho desde entonces), aquí está el texto completo:

La generación de lenguaje natural (NLG) es un tema bien estudiado entre la comunidad de NLP. Un enfoque para abordar el desafío de la generación de texto es factorizar la probabilidad de una secuencia de tokens (por ejemplo, palabras o Codificación de pares de bytes) (P(x_1, ldots, x_n)) en la multiplicación de las probabilidades de obtener cada una de las fichas (x_1)…, (x_n) condicionado a las fichas que lo preceden: (prod_^P(x_t|x_{. Dado un conjunto de datos de entrenamiento, uno podría entrenar dicho modelo para maximizar la probabilidad del próximo token en cada paso de tiempo. Una vez que se ha entrenado el modelo, puede generar texto tomando muestras de la distribución, un token a la vez. Fácil como la brisa.

Con el auge de los métodos de aprendizaje profundo, NLG se ha vuelto cada vez mejor. Recientemente, OpenAI ha empujado los límites, con el lanzamiento de GPT-2. Este modelo utiliza el conocido Arquitectura de transformadores: para calcular la distribución sobre el siguiente token, el modelo utiliza simultáneamente los tokens anteriores mediante un mecanismo de autoatención.

Recientemente, HuggingFace ha lanzó una API facilitando el acceso a GPT-2. Una de sus características es generar texto usando el modelo pre-entrenado:

spell run --github-url https://github.com/huggingface/transformers.git 
  --pip tqdm 
  --pip boto3 
  --pip requests 
  --pip regex 
  --pip sacremoses 
  "python examples/run_generation.py 
    --model_type=gpt2 
    --length=70 
    --prompt=' ' 
    --model_name_or_path=gpt2"
💫 Casting spell #1…
✨ Stop viewing logs with ^C
✨ Machine_Requested… done
✨ Building… done
✨ Run is running
…
…
…
$5.30-$10.00

FREE SHIPPING

Items without a shipping address will be delivered to your confirmation email when you purchase your product.

Use "POOL" when ordering; deliveries to POOL addresses are completely separate from shipping.<|endoftext|>Earth's spin to new low the closer Earth takes to the Sun's
✨ Saving… done
✨ Pushing… done
🎉 Total run time: 1m7.057677s
🎉 Run 1 complete

¡Eso fue fácil! OpenAI ha utilizado diversos datos que se encuentran en la web para entrenar el modelo, por lo que el texto generado puede ser prácticamente cualquier texto de apariencia natural. Pero, ¿y si en lugar de diversidad, quisiéramos generar un tipo de texto específico? ¡Intentemos generar chistes! Para hacerlo, tendremos que entrenar el modelo usando un conjunto de datos de chistes. Desafortunadamente, ¡obtener tal conjunto de datos sería ridículamente difícil! Para entrenar GPT-2, que tiene 124 millones de pesos para aprender (y esta es simplemente la versión más pequeña de la arquitectura), ¡necesitamos una gran cantidad de datos! Pero, ¿cómo vamos a conseguir tantos chistes? La respuesta corta es: no lo haremos.

Aprender a generar chistes implica aprender a generar texto de aspecto natural, además de asegurarse de que este texto sea divertido. La primera parte es donde ocurre la mayor parte del aprendizaje. Utilizando la versión previamente entrenada de GPT-2 como punto de partida, el modelo no tendrá que aprender a generar texto de aspecto natural desde cero. Todo lo que tendrá que aprender es a concentrar la distribución sobre el texto que es divertido. Un conjunto de datos relativamente pequeño servirá para la tarea.

No me malinterpreten, el conjunto de datos que usaremos no es lo suficientemente grande como para aprender algo útil de manera significativa. Además, entrenar a un modelo para generalizar el concepto de humor es un problema difícil. Sin embargo, para el propósito de esta publicación (aprender a usar y ajustar un modelo como GPT-2), esto servirá: veremos cómo el conjunto de datos cambia la distribución del modelo hacia el texto que se ve, hasta cierto punto, como chistes

Usaremos chistes de una sola línea de conjunto de datos de chistes cortos para afinar GPT-2. Al ser más corto que el chiste promedio, será más fácil para el modelo aprender su distribución. Entonces, lo primero es lo primero, obtengamos los datos:

spell run "wget -O data.csv https://raw.githubusercontent.com/amoudgl/short-jokes-dataset/master/data/onelinefun.csv && python -c "import csv; f_in = open('data.csv', 'r'); f_out = open('data.txt', 'w'); f_out.write('n'.join(row['Joke'] for row in csv.DictReader(f_in)))""
💫 Casting spell #2…
✨ Stop viewing logs with ^C
✨ Building… done
✨ Machine_Requested… done
✨ Run is running
--2019-11-09 21:36:14--  https://raw.githubusercontent.com/amoudgl/short-jokes-dataset/master/data/onelinefun.csv
Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 151.101.0.133, 151.101.64.133, 151.101.128.133, ...
Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|151.101.0.133|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 253462 (248K) [text/plain]
Saving to: ‘data.csv’

     0K .......... .......... .......... .......... .......... 20% 3.34M 0s
    50K .......... .......... .......... .......... .......... 40% 6.72M 0s
   100K .......... .......... .......... .......... .......... 60%  167M 0s
   150K .......... .......... .......... .......... .......... 80%  122M 0s
   200K .......... .......... .......... .......... .......   100% 6.55M=0.03s

2019-11-09 21:36:14 (8.14 MB/s) - ‘data.csv’ saved [253462/253462]

✨ Saving… done
✨ Pushing… done
🎉 Total run time: 13.07418s
🎉 Run 2 complete

HuggingFace ya nos proporcionó un script para ajustar GPT-2:

spell run --github-url https://github.com/huggingface/transformers.git 
  --pip tqdm 
  --pip boto3 
  --pip requests 
  --pip regex 
  --pip sacremoses 
  -m runs/2/data.txt 
  "python examples/run_lm_finetuning.py 
    --output_dir=output 
    --model_type=gpt2 
    --model_name_or_path=gpt2 
    --per_gpu_train_batch_size=2 
    --num_train_epochs=10 
    --do_train 
    --train_data_file=data.txt"
💫 Casting spell #3…
✨ Stop viewing logs with ^C
✨ Machine_Requested… done
✨ Building… done
✨ Mounting… done
✨ Run is running
…
…
…
🎉 Total run time: 44h36m34.553059s
🎉 Run 3 complete

Tenga en cuenta que los datos descargados de la ejecución anterior se montan utilizando el -m bandera. Aunque hemos usado un conjunto de datos pequeño (ejemplos de 3K), ejecutar 10 épocas en una CPU tomó alrededor de 44 horas. Solo muestra qué tan grande es el modelo. Esta es la razón por la que debe usar una GPU si desea usar un conjunto de datos más grande o ejecutar muchos experimentos (por ejemplo, ajustar hiperparámetros).

Intentemos generar un chiste, luego de montar el resultado de la ejecución anterior:

spell run --github-url https://github.com/huggingface/transformers.git 
  --pip tqdm 
  --pip boto3 
  --pip requests 
  --pip regex 
  --pip sacremoses 
  -m runs/3/output 
  "python examples/run_generation.py 
    --model_type=gpt2 
    --length=70 
    --prompt=' ' 
    --model_name_or_path=output"
💫 Casting spell #4…
✨ Stop viewing logs with ^C
✨ Machine_Requested… done
✨ Building… done
✨ Run is running
…
…
…
"I've got seven fingers! But I don't have those!"
Your childhood might be difficult, but at least it doesn't taste like your grandfather's.
Funny things never happen, in life.
Friends, We've met on the beach. What's wrong with you?
If I'm speaking honestly, I could use some
✨ Saving… done
✨ Pushing… done
🎉 Total run time: 51.047054s
🎉 Run 4 complete

El modelo ha aprendido a generar oraciones cortas, lo cual es típico de nuestro conjunto de datos. ¡Esta estadística de datos relativamente fácil de entender fue bien aprendida! En cuanto a lo divertido que es el modelo, bueno… ¡Te dejo a ti para que juzgues!

Fuente del artículo

Deja un comentario