minGPT

minpt

Una reimplementación de GPT en PyTorch, tanto de entrenamiento como de inferencia. minGPT intenta ser pequeño, limpio, interpretable y educativo, ya que la mayoría de las implementaciones del modelo GPT disponibles actualmente pueden ser un poco extensas. GPT no es un modelo complicado y esta implementación tiene aproximadamente 300 líneas de código (consulte mingpt/model.py). Lo único que sucede es que una secuencia de índices ingresa a un transformador y sale una distribución de probabilidad sobre el siguiente índice de la secuencia. La mayor parte 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 lograr eficiencia.

nota (enero de 2023) : aunque puedo seguir aceptando y cambiando algunos detalles, minGPT se encuentra en un estado semiarchivado. Para conocer desarrollos más recientes, consulte mi reescritura de nanoGPT. Básicamente, se hizo referencia a minGPT en una amplia variedad de lugares (cuadernos, blogs, cursos, libros, etc.), lo que me hizo menos dispuesto a realizar los cambios más importantes que quería hacer para hacer avanzar el código. También quería cambiar un poco la dirección, de un enfoque exclusivo en la educación a algo que aún sea simple y pirateable pero que tenga fuerza (reproduce puntos de referencia de la industria de tamaño mediano, acepta algunas compensaciones para ganar eficiencia en tiempo de ejecución, etc.).

La biblioteca minGPT consta de tres archivos: mingpt/model.py contiene la definición real del modelo Transformer, mingpt/bpe.py contiene un codificador de par de bytes ligeramente refactorizado que traduce entre texto y secuencias de números enteros exactamente como lo hizo OpenAI en GPT, mingpt/trainer. py es un código repetitivo de PyTorch (independiente de GPT) que entrena el modelo. Luego hay una serie de demostraciones y proyectos que utilizan la biblioteca en la carpeta projects :

projects/adder entrena un GPT desde cero para sumar números (inspirado en la sección de suma en el documento GPT-3)
projects/chargpt entrena un GPT para que sea un modelo de lenguaje a nivel de caracteres en algún archivo de texto de entrada
demo.ipynb muestra un uso mínimo de GPT y Trainer en formato de cuaderno en un ejemplo de clasificación simple
generate.ipynb muestra cómo se puede cargar un GPT2 previamente entrenado y generar texto si se le indica algo

Instalación de la biblioteca

Si desea import mingpt a su proyecto:

 git clone https://github.com/karpathy/minGPT.git
cd minGPT
pip install -e .

Uso

Así es como crearías una instancia de un GPT-2 (versión de parámetro 124M):

 from mingpt . model import GPT
model_config = GPT . get_default_config ()
model_config . model_type = 'gpt2'
model_config . vocab_size = 50257 # openai's model vocabulary
model_config . block_size = 1024  # openai's model block_size (i.e. input context length)
model = GPT ( model_config )

Y así es como lo entrenarías:

 # your subclass of torch.utils.data.Dataset that emits example
# torch LongTensor of lengths up to 1024, with integers from [0,50257)
train_dataset = YourDataset ()

from mingpt . trainer import Trainer
train_config = Trainer . get_default_config ()
train_config . learning_rate = 5e-4 # many possible options, see the file
train_config . max_iters = 1000
train_config . batch_size = 32
trainer = Trainer ( train_config , model , train_dataset )
trainer . run ()

Consulte demo.ipynb para ver un ejemplo más concreto.

Pruebas unitarias

La cobertura aún no es muy sorprendente, pero:

 python -m unittest discover tests

todos

agregue una demostración de ajuste fino de gpt-2 en un archivo de texto dado arbitrariamente
agregar demostración del agente de diálogo
mejores documentos de resultados para proyectos existentes (adder, chargpt)
agregue precisión mixta y ventajas de escalamiento de entrenamiento relacionadas
soporte de capacitación distribuida
reproducir algunos puntos de referencia en proyectos/, por ejemplo, text8 u otro modelado de lenguaje
registro adecuado en lugar de imprimir declaración hora de aficionado jaja
Probablemente debería tener un archivo de requisitos.txt...
Debería ser posible cargar muchos otros pesos de modelo además de gpt2-*

Referencias

Código:

openai/gpt-2 tiene la definición del modelo en TensorFlow, pero no el código de entrenamiento
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.

Preentrenamiento generativo a partir de píxeles (Imagen GPT)

Cuando trabajamos con imágenes, elegimos la permutación de identidad πi = i para 1 ≤ i ≤ n, también conocida como orden ráster.
Creamos nuestra propia paleta de colores de 9 bits agrupando valores de píxeles (R, G, B) usando k-medias con k = 512.
Nuestro modelo más grande, iGPT-XL, contiene L = 60 capas y utiliza un tamaño de incrustación de d = 3072 para un total de 6,8 mil millones de parámetros.
Nuestro siguiente modelo más grande, iGPT-L, es esencialmente idéntico a GPT-2 con L = 48 capas, pero contiene un tamaño de incrustación ligeramente más pequeño de d = 1536 (frente a 1600) para un total de 1,4 mil millones de parámetros.
Usamos el mismo código de modelo que GPT-2, excepto que inicializamos los pesos de manera dependiente de la capa como en Sparse Transformer (Child et al., 2019) e inicializamos a cero todas las proyecciones que producen logits.
También entrenamos iGPT-M, un modelo de parámetros de 455M con L = 36 y d = 1024
iGPT-S, un modelo de parámetros de 76M con L = 24 y d = 512 (vale, ¿y cuántas cabezas? Parece que el código Github dice 8)
Al entrenar previamente iGPT-XL, usamos un tamaño de lote de 64 y entrenamos para 2 millones de iteraciones, y para todos los demás modelos usamos un tamaño de lote de 128 y entrenamos para 1 millón de iteraciones.
Adán con β1 = 0,9 y β2 = 0,95
La tasa de aprendizaje se calienta durante una época y luego desciende a 0.
No utilizamos una disminución de peso porque aplicar una pequeña disminución de peso de 0,01 no cambió la calidad de la representación.
iGPT-S lr 0,003
No se utiliza abandono.