minGPT TF

minGPT-TF

Una reimplementación de TensorFlow de mingpt

Cuadernos

play_math.ipynb y play_char.ipynb entrenados en colab. Los enlaces están en la parte superior de cada cuaderno para entrenar el modelo en colab. play_char.ipynb batch_size del portátil se reduce para caber en la memoria GPU de colab. Cambie los parámetros según la memoria de la GPU.

minGPT - Léame

Una reimplementación de PyTorch del entrenamiento GPT. minGPT intenta ser pequeño, limpio, interpretable y educativo, ya que la mayoría de los disponibles actualmente son un poco extensos. GPT no es un modelo complicado y esta implementación consta apropiadamente de unas 300 líneas de código, incluido el texto estándar y un módulo de autoatención causal personalizado totalmente innecesario. De todos modos, lo único que sucede es que una secuencia de índices entra en una secuencia de bloques transformadores y sale una distribución de probabilidad del siguiente índice. El resto de la complejidad consiste simplemente en ser inteligente con el procesamiento por lotes (tanto entre ejemplos como a lo largo de la longitud de la secuencia) para que el entrenamiento sea eficiente.

La "biblioteca" principal de minGPT (ja) consta de dos archivos: mingpt/model.py contiene la definición real del modelo Transformer y mingpt/trainer.py es un texto estándar de PyTorch (independiente de GPT) que entrena el modelo. Los cuadernos de Jupyter adjuntos muestran cómo se puede utilizar la "biblioteca" (ja) para entrenar modelos de secuencia:

• play_math.ipynb entrena un GPT centrado en la suma (inspirado en la sección de suma del documento GPT-3)
• play_char.ipynb entrena un GPT para que sea un modelo de lenguaje a nivel de carácter en texto arbitrario, similar a mi antiguo char-rnn pero con un transformador en lugar de un RNN
• play_words.ipynb una versión BPE que aún no existe

Con un codificador bpe, entrenamiento distribuido y tal vez fp16, esta implementación puede reproducir los resultados de GPT-1/GPT-2, aunque no lo he probado $$$. Es probable que GPT-3 esté fuera de su alcance, ya que tengo entendido que no cabe en la memoria de la GPU y requiere un tratamiento paralelo al modelo más cuidadoso.

Uso de ejemplo

Este código es lo suficientemente simple como para piratearlo en línea, no "usado", pero la API actual se parece a:

 # you're on your own to define a class that returns individual examples as PyTorch LongTensors
from torch . utils . data import Dataset
train_dataset = MyDataset (...)
test_dataset = MyDataset (...)

# construct a GPT model
from mingpt . model import GPT , GPTConfig
mconf = GPTConfig ( vocab_size , block_size , n_layer = 12 , n_head = 12 , n_embd = 768 ) # a GPT-1
model = GPT ( mconf )

# construct a trainer
from mingpt . trainer import Trainer , TrainerConfig
tconf = TrainerConfig ( max_epochs = 10 , batch_size = 256 )
trainer = Trainer ( model , train_dataset , test_dataset , tconf )
trainer . train ()
# (... enjoy the show for a while... )

# sample from the model (the [None, ...] and [0] are to push/pop a needed dummy batch dimension)
from mingpt . utils import sample
x = torch . tensor ([ 1 , 2 , 3 ], dtype = torch . long )[ None , ...] # context conditioning
y = sample ( model , x , steps = 30 , temperature = 1.0 , sample = True , top_k = 5 )[ 0 ]
print ( y ) # our model filled in the integer sequence with 30 additional likely integers

Referencias

Código:

• openai/gpt-2 tiene el modelo pero no el código de entrenamiento, y en TensorFlow
• openai/image-gpt tiene alguna modificación más moderna similar a gpt-3 en su código, una buena referencia también
• huggingface/transformers tiene un ejemplo de modelado de lenguaje. Tiene todas las funciones pero, como resultado, también es algo difícil de rastrear. Por ejemplo, algunas funciones grandes tienen hasta un 90% de código no utilizado detrás de varias declaraciones de ramificación que no se utilizan en la configuración predeterminada del modelado de lenguaje simple.

Artículos + algunas notas de implementación:

Mejora de la comprensión del lenguaje mediante preentrenamiento generativo (GPT-1)

• Nuestro modelo sigue en gran medida el trabajo del transformador original.
• Entrenamos un transformador solo decodificador de 12 capas con cabezas de autoatención enmascaradas (768 estados dimensionales y 12 cabezas de atención). Para las redes de avance de posición, utilizamos estados internos de 3072 dimensiones.
• Tasa de aprendizaje máxima de Adam de 2,5e-4. (posteriormente GPT-3 para este tamaño de modelo usa 6e-4)
• Decaimiento de LR: aumentado linealmente desde cero durante las primeras 2000 actualizaciones y recocido a 0 usando un programa de coseno
• Entrenamos durante 100 épocas en minilotes de 64 secuencias contiguas de 512 tokens muestreadas aleatoriamente.
• Dado que Layernorm se utiliza ampliamente en todo el modelo, una simple inicialización de peso de N(0, 0,02) fue suficiente
• Vocabulario de codificación de par de bytes (BPE) con 40.000 fusiones
• abandonos residuales, de incrustación y de atención con una tasa de 0,1 para la regularización.
• versión modificada de la regularización L2 propuesta en (37), con w = 0,01 en todos los pesos sin sesgo o ganancia
• Para la función de activación, utilizamos la Unidad Lineal de Error Gaussiano (GELU).
• Usamos incrustaciones de posiciones aprendidas en lugar de la versión sinusoidal propuesta en el trabajo original.
• Para realizar ajustes: agregamos abandono al clasificador con una tasa de 0,1. tasa de aprendizaje de 6.25e-5 y un tamaño de lote de 32. 3 épocas. Usamos un programa de caída de la tasa de aprendizaje lineal con un calentamiento superior al 0,2% del entrenamiento. λ se fijó en 0,5.
• El modelo GPT-1 tiene 12 capas y d_model 768, ~117M parámetros

Los modelos de lenguaje son estudiantes multitarea sin supervisión (GPT-2)

• LayerNorm se movió a la entrada de cada subbloque, similar a una red residual de preactivación
• Se agregó una normalización de capa adicional después del bloque final de autoatención.
• Se utiliza la inicialización modificada que tiene en cuenta la acumulación en la ruta residual con la profundidad del modelo. Escalamos los pesos de las capas residuales en la inicialización por un factor de 1/√N donde N es el número de capas residuales. (Extraño porque en su código publicado solo puedo encontrar un uso simple del antiguo 0.02... en su lanzamiento de image-gpt encontré que se usaba para c_proj, y aun así solo para attn, no para mlp. eh. https: //github.com/openai/image-gpt/blob/master/src/model.py)
• el vocabulario se amplía a 50.257
• aumentar el tamaño del contexto de 512 a 1024 tokens
• Se utiliza un tamaño de lote mayor de 512.
• GPT-2 usó 48 capas y d_model 1600 (frente a las 12 capas originales y d_model 768). ~1.542B parámetros

Los modelos de lenguaje aprenden con pocas posibilidades (GPT-3)

• GPT-3: 96 capas, 96 cabezales, con d_model de 12288 (175B parámetros).
• Tipo GPT-1: 12 capas, 12 cabezales, d_model 768 (125M)
• Usamos el mismo modelo y arquitectura que GPT-2, incluida la inicialización modificada, la prenormalización y la tokenización reversible que se describen allí.
• Usamos patrones de atención dispersos alternos, densos y con bandas locales en las capas del transformador, similar al Sparse Transformer.
• siempre tenemos la capa de avance cuatro veces el tamaño de la capa de cuello de botella, dff = 4 ∗ dmodel
• Todos los modelos utilizan una ventana de contexto de nctx = 2048 tokens.
• Adán con β1 = 0,9, β2 = 0,95 y eps = 10−8
• Todos los modelos utilizan una caída de peso de 0,1 para proporcionar una pequeña cantidad de regularización. (NOTA: GPT-1 usó 0.01, creo, ver arriba)
• recortar la norma global del gradiente en 1.0
• Calentamiento de LR lineal sobre los primeros 375 millones de tokens. Luego use la caída del coseno para una tasa de aprendizaje de hasta el 10% de su valor, más de 260 mil millones de tokens.
• Aumente gradualmente el tamaño del lote de forma lineal desde un valor pequeño (32 000 tokens) hasta el valor total durante los primeros 4 a 12 mil millones de tokens de entrenamiento, según el tamaño del modelo.
• Siempre se utiliza una ventana de contexto de tiempo completa de tamaño 2048, con un delimitador de token de FIN DE DOCUMENTO especial.

Licencia

MIT