gpt 2 simple

GPT-2-simple

Un paquete simple de Python que envuelve los scripts de generación y ajuste fino existentes para el modelo de generación de texto GPT-2 de OpenAI (específicamente las versiones "pequeñas" 124m y "medianas" de 355m de 355m). Además, este paquete permite una generación más fácil de texto, generando en un archivo para una curación fácil, lo que permite que los prefijos obligen al texto a comenzar con una frase dada.

Este paquete incorpora y realiza cambios mínimos de bajo nivel a:

• Gestión de modelos del Repo GPT-2 oficial de OpenAI (licencia del MIT)
• Fineting de modelo de la bifurcación de Neil Shepperd de GPT-2 (licencia del MIT)
• Gestión de salida de generación de texto de TextGenrnn (Licencia MIT / también creada por mí)

Para la sintonización, se recomienda usar una GPU, aunque puede generar utilizando una CPU (aunque mucho más lentamente). Si está entrenando en la nube, se recomienda encarecidamente el uso de un cuaderno colaboratorio o una VM de Google Compute Engine con la imagen de aprendizaje profundo TensorFlow. (Como el modelo GPT-2 está alojado en GCP)

Puede usar GPT-2-Simple para volver a entrenar un modelo utilizando una GPU de forma gratuita en este cuaderno colaboratorio, que también demos características adicionales del paquete.

Nota: El desarrollo en GPT-2-Simple se ha superado principalmente por Aitextgen, que tiene capacidades de generación de texto de IA similares con un tiempo de capacitación más eficiente y uso de recursos. Si no necesita usar TensorFlow, le recomiendo usar AitextGen. Los puntos de control entrenados con GPT-2-Simple también se pueden cargar usando Aitextgen.

Instalar

GPT-2-Simple se puede instalar a través de PYPI:

pip3 install gpt-2-simple

También deberá instalar la versión TensorFlow 2.x correspondiente (Min 2.5.1) para su sistema (por ejemplo, tensorflow o tensorflow-gpu ).

Uso

Un ejemplo para descargar el modelo al sistema local, finalmente unirlo en un conjunto de datos. y generando algún texto.

ADVERTENCIA: ¡El modelo de 124 m preventivo, y por lo tanto cualquier modelo Finetuned, es de 500 MB! (El modelo de 355m previsto es 1.5 GB)

 import gpt_2_simple as gpt2
import os
import requests

model_name = "124M"
if not os . path . isdir ( os . path . join ( "models" , model_name )):
	print ( f"Downloading { model_name } model..." )
	gpt2 . download_gpt2 ( model_name = model_name )   # model is saved into current directory under /models/124M/


file_name = "shakespeare.txt"
if not os . path . isfile ( file_name ):
	url = "https://raw.githubusercontent.com/karpathy/char-rnn/master/data/tinyshakespeare/input.txt"
	data = requests . get ( url )

	with open ( file_name , 'w' ) as f :
		f . write ( data . text )


sess = gpt2 . start_tf_sess ()
gpt2 . finetune ( sess ,
              file_name ,
              model_name = model_name ,
              steps = 1000 )   # steps is max number of training steps

gpt2 . generate ( sess )

Los puntos de control del modelo generado son de forma predeterminada en /checkpoint/run1 . Si desea cargar un modelo desde esa carpeta y generar texto:

 import gpt_2_simple as gpt2

sess = gpt2 . start_tf_sess ()
gpt2 . load_gpt2 ( sess )

gpt2 . generate ( sess )

Al igual que con TextGenRNN, puede generar y guardar texto para su uso posterior (por ejemplo, una API o un bot) utilizando el parámetro return_as_list .

 single_text = gpt2 . generate ( sess , return_as_list = True )[ 0 ]
print ( single_text )

Puede pasar un parámetro run_name a finetune y load_gpt2 si desea almacenar/cargar varios modelos en una carpeta de checkpoint .

También hay una interfaz de línea de comandos tanto para Finetuning como para la generación con fuertes valores predeterminados para simplemente ejecutarse en una VM Cloud W/ GPU. Para Finetuning (que también descargará el modelo si no está presente):

gpt_2_simple finetune shakespeare.txt

Y para la generación, que genera textos a archivos en una carpeta gen :

gpt_2_simple generate

La mayoría de los mismos parámetros disponibles en las funciones están disponibles como argumentos CLI, por ejemplo:

gpt_2_simple generate --temperature 1.0 --nsamples 20 --batch_size 20 --length 50 --prefix " <|startoftext|> " --truncate " <|endoftext|> " --include_prefix False --nfiles 5

Vea a continuación para ver qué hacen algunos de los argumentos de CLI.

NB: Reinicie la sesión de Python primero si desea Finetune en otro conjunto de datos o cargar otro modelo.

Diferencias entre GPT-2-simple y otras utilidades de generación de texto

El método que GPT-2 usa para generar texto es ligeramente diferente a aquellos como otros paquetes como TextGenrnn (específicamente, generando la secuencia de texto completa puramente en la GPU y decodificándola más tarde), que no se puede solucionar fácilmente sin piratear el código de modelo subyacente. Como resultado:

• En general, GPT-2 es mejor para mantener el contexto durante toda su longitud de generación, lo que lo hace bueno para generar texto conversacional. El texto también es generalmente correcto gramáticamente, con una capitalización adecuada y pocos errores tipográficos.
• El modelo GPT-2 original fue entrenado en una gran variedad de fuentes, lo que permite que el modelo incorporara modismos no vistos en el texto de entrada.
• GPT-2 solo puede generar un máximo de 1024 tokens por solicitud (aproximadamente 3-4 párrafos de texto en inglés).
• GPT-2 no puede detenerse al principio de llegar a un token final específico. (Solución alternativa: pase el parámetro truncate a una función generate para recopilar solo texto hasta que un token final especificado. Es posible que desee reducir length adecuadamente).
• Las temperaturas más altas funcionan mejor (por ejemplo, 0.7 - 1.0) para generar un texto más interesante, mientras que otros marcos funcionan mejor entre 0.2 - 0.5.
• Al Finetune GPT-2, no tiene sentido del comienzo o el final de un documento dentro de un texto más grande. Deberá usar una secuencia de personajes a medida para indicar el comienzo y el final de un documento. Luego, mientras se genera, puede especificar un prefix dirigido a las secuencias de token iniciales y una truncate dirigida a la secuencia del token final. También puede configurar include_prefix=False para descartar el token de prefijo mientras se genera (por ejemplo, si es algo no deseado como <|startoftext|> ).
• Si pasa un archivo .csv de columna de una sola columna a finetune() , analizará automáticamente el CSV en un formato ideal para capacitar con GPT-2 (incluida la preparación <|startoftext|> y sufijo <|endoftext|> a cada documento de texto, por lo que los trucos truncate anteriores son útiles cuando se generan salida). Esto es necesario para manejar las cotizaciones y las nuevas líneas en cada documento de texto correctamente.
• GPT-2 le permite generar textos en paralelo estableciendo un batch_size que sea divisible en nsamples , lo que resulta en una generación mucho más rápida. ¡Funciona muy bien con una GPU (puede establecer batch_size hasta 20 en el K80 de Colaboratory)!
• Debido a la arquitectura de GPT-2, se escala muy bien con GPU más potentes. Para el modelo de 124 m, si desea entrenar durante períodos de tiempo más largos, la GPU de P100 de GCP es aproximadamente 3 veces más rápido que un K80/T4 por solo 3 veces el precio, lo que lo hace complejo de precios (el V100 es aproximadamente 1.5 veces más rápido que el P100 pero aproximadamente 2 veces el precio). El P100 usa el 100% de la GPU incluso con batch_size=1 , y aproximadamente el 88% de la GPU V100.
• Si tiene un modelo GPT-2 parcialmente capacitado y desea continuar con Finetuninglo, puede establecer overwrite=True a Finetune, que continuará entrenando y eliminará la iteración anterior del modelo sin crear una copia duplicada. Esto puede ser especialmente útil para transferir el aprendizaje (por ejemplo, Finetune GPT-2 en un conjunto de datos, luego Finetune en otro conjunto de datos para obtener una "fusión" de ambos conjuntos de datos).
• Si su conjunto de datos de texto de entrada es masivo (> 100 mb), es posible que desee preinsenciar y comprimir el conjunto de datos usando gpt2.encode_dataset(file_path) . La salida es un archivo .npz comprimido que se cargará mucho más rápido en la GPU para Finetuning.
• El modelo "grande" de 774m puede admitir ficas porque hará que las GPU modernas se salgan de la memoria (puede tener suerte si usa una GPU P100 en Colaboratory). Sin embargo, aún puede generar a partir del modelo predeterminado de pretrada usando gpt2.load_gpt2(sess, model_name='774M') y gpt2.generate(sess, model_name='774M') .
• El modelo verdadero "extra grande" de 1558m puede no funcionar fuera de la caja con la GPU incluida con el cuaderno Colaboratory. Se necesitan más pruebas para identificar configuraciones óptimas para ello.

Aplicaciones interactivas que usan GPT-2-simple

• GPT2-Small-Aplicación utilizando el modelo predeterminado de GPT-2 124M Pretraled
• GPT2-REDDIT-Aplicación para generar títulos reddit basados ​​en un subreddit especificado y/o palabras clave (s)
• GPT2-MTG-Aplicación para generar magia: las cartas de reunión

Ejemplos de generación de texto usando GPT-2-simple

• Resetera - Discusiones generadas por el foro de videojuegos (GitHub con vertederos)
• /R/LegalAdvice - Generación de títulos (GitHub con vertederos)
• Hacker News - Decenas de miles de títulos de presentación de noticias de hackers generados

Mantenedor/creador

Max Woolf (@minimaxir)

Los proyectos de código abierto de Max son apoyados por su patreón. Si le resulta útil este proyecto, se agradecen cualquier contribución monetaria al Patreon y se utilizará en un buen uso creativo.

Licencia

MIT

Descargo de responsabilidad

Este repositorio no tiene afiliación ni relación con OpenAI.