gpt neo
v1.1.1
* A partir de agosto de 2021, el código ya no se mantiene. Se conserva aquí en forma de archivo para las personas que deseen seguir usándolo.
? ¿1T o reventar a mis amigos?
Una implementación de modelos similares a GPT3 paralelos de modelos y datos utilizando la biblioteca mesh-tensorflow.
Si solo estás aquí para jugar con nuestros modelos previamente entrenados, te recomendamos encarecidamente que pruebes la integración de HuggingFace Transformer.
El entrenamiento y la inferencia son oficialmente compatibles con TPU y también deberían funcionar en GPU. Este repositorio se archivará (en su mayor parte) a medida que nos centremos en nuestro repositorio específico de GPU, GPT-NeoX.
Además de la funcionalidad que ofrece GPT-3, también ofrecemos lo siguiente:
NB, si bien neo técnicamente puede ejecutar un paso de entrenamiento con más de 200 mil millones de parámetros, es muy ineficiente en esas escalas. Esto, además del hecho de que muchas GPU estuvieron disponibles para nosotros, entre otras cosas, nos impulsó a trasladar el desarrollo a GPT-NeoX.
Actualización 21/03/2021:
Estamos orgullosos de lanzar dos modelos GPT-Neo previamente entrenados en The Pile; los pesos y configuraciones se pueden descargar gratuitamente desde the-eye.eu.
1.3B: https://mystic.the-eye.eu/public/AI/gptneo-release/GPT3_XL/
2.7B: https://mystic.the-eye.eu/public/AI/gptneo-release/GPT3_2-7B/
Para obtener más información sobre cómo configurarlos, consulte el cuaderno de colab o lea el resto del archivo Léame.
| Modelo y tamaño | pila BPB | Pila de PPL | Wikitexto PPL | Lambada PPL | Lambada Acc | Winogrande | Hellaswag |
|---|---|---|---|---|---|---|---|
| GPT-Neo 125M | ----- | ----- | 32.285 | 30.266 | 37,36% | 50,43% | 28,67% |
| GPT-3 125M | ----- | ----- | ----- | 18.6 | 42,7% | 52,0% | 33,7% |
| GPT-Neo 350M | ----- | ----- | 22.5657 | 13.876 | 47,27% | 51,14% | 32,16% |
| GPT-3 350M | ----- | ----- | ----- | 9.09 | 54,3% | 52,1% | 43,6% |
| GPT-3 Ada | 0.9631 | ----- | ----- | 9.954 | 51,60% | 52,90% | 35,93% |
| GPT-Neo 1.3B | 0.7527 | 6.159 | 13.10 | 7.498 | 57,23% | 55,01% | 38,66% |
| GPT-3 1.3B | ----- | ----- | ----- | 5.44 | 63,6% | 58,7% | 54,7% |
| GPT-2 1.5B | 1.0468 | ----- | 17.48 | 10.634 | 51,21% | 59,40% | 40,03% |
| GPT-Neo 2.7B | 0.7165 | 5.646 | 11.39 | 5.626 | 62,22% | 56,50% | 42,73% |
| GPT-3 2.7B | ----- | ----- | ----- | 4.60 | 67,1% | 62,3% | 62,8% |
| Modelo y tamaño | MatemáticasQA | PubMedQA | piqá |
|---|---|---|---|
| GPT-Neo 125M | 22,78% | 55,10% | 63,06% |
| GPT-3 125M | ----- | ----- | 64,6% |
| GPT-Neo 350M | 23,45% | 53,80% | 65,07% |
| GPT-3 350M | ----- | ----- | 70,2% |
| GPT-3 Ada | 24,29% | 52,80% | 68,88% |
| GPT-Neo 1.3B | 24,05% | 54,40% | 71,11% |
| GPT-3 1.3B | ----- | ----- | 75,1% |
| GPT-2 1.5B | 23,64% | 58,33% | 70,78% |
| GPT-Neo 2.7B | 24,72% | 57,54% | 72,14% |
| GPT-3 2.7B | ----- | ----- | 75,6% |
Nota: Todas las evaluaciones se realizaron utilizando nuestro arnés de evaluación. Algunos resultados para GPT-2 y GPT-3 no coinciden con los valores informados en los artículos respectivos. Actualmente estamos investigando el motivo y agradeceríamos mucho recibir comentarios y realizar más pruebas de nuestro arnés de evaluación.
git clone https://github.com/EleutherAI/GPTNeo
cd GPTNeo
pip3 install -r requirements.txtRegístrese en Google Cloud Platform y cree un depósito de almacenamiento.
Cree su VM a través de un shell de Google ( https://ssh.cloud.google.com/ ) con ctpu up --vm-only para que pueda conectarse a su depósito de Google y TPU e instalar los requisitos con pip (ver arriba) .
Google Colab proporciona tpu-v8 de forma gratuita, lo que debería ser suficiente para ajustar nuestros modelos hasta tamaños GPT3XL (1,5 mil millones de parámetros). Haga clic para revisar nuestro cuaderno de colaboración de ejemplo.
Para obtener instrucciones más detalladas, consulte nuestra Guía de capacitación a continuación.
También puedes optar por entrenar GPTNeo localmente en tus GPU. Para hacerlo, puede omitir los pasos anteriores de configuración de la nube de Google y clonar el repositorio localmente. Ejecute la Guía de capacitación a continuación, luego, cuando ejecute main.py, simplemente debe omitir el indicador tpu y, en su lugar, pasar los ID de GPU.
Nota: Algunos usuarios han informado que han tenido dificultades para que MTF reconozca sus GPU. Consulte aquí para obtener detalles e instrucciones sobre cómo solucionarlo.
Una vez que tenga un modelo entrenado o haya descargado uno de nuestros modelos previamente entrenados, generar texto es tan simple como ejecutar el script main.py con el indicador --predict activado. Puede pasar una ruta a su archivo de texto de aviso con el indicador --prompt , así:
python3 main.py --predict --prompt < example_prompt.txt > --tpu < tpu_name > --model < config_name >o, si usa GPU:
python3 main.py --predict --prompt < example_prompt.txt > --gpu_ids < device:GPU:0 device:GPU: 1> --model < config_name >Le recomendamos que utilice el tokenizador GPT2 previamente entrenado de Huggingface con nuestro repositorio (las instrucciones se proporcionan a continuación), pero si desea entrenar un modelo con un tamaño de vocabulario diferente, le brindamos funciones para entrenar su propio tokenizador de esta manera:
python data/train_tokenizer.py
--base_dir ./path/to/your/txt/files
--output_dir ./output/path
--file_type txt
--vocab_size 50257
# if it succeeded, you should see the message
# 'tokenizer saved at ./output/path/byte-level-bpe.tokenizer.json' Si solo desea probar el entrenamiento, puede omitir este paso y descargar algunos datos ficticios como este:
wget https://storage.googleapis.com/connors-datasets/bundestag/bundestag_0.tfrecords
Luego copie los datos a su depósito o, si usa GPU, a un directorio local:
gsutil cp bundestag_0.tfrecords gs://<your bucket>/
Si usa sus propios datos para entrenar, puede usar el script data/create_tfrecords.py para codificar sus datos de texto en tfrecords.
Sus datos deben estar en forma de muchos archivos .txt normales (un documento por archivo) o en cualquier formato admitido por lm_dataformat.
Puede ejecutar el script sin parámetros para ver la ayuda de todas las opciones.
En modo documento Cada ejemplo en tfrecords es un documento (de tamaño variable). Esto se debe utilizar con los modos de muestreo documents_fixed y documents_random (para obtener más detalles, consulte la sección de referencia de parámetros). El modo de documento es el modo predeterminado.
El siguiente comando tokenizará todos los archivos en formatos aceptables en base_dir usando el tokenizador gpt2 y los guardará en output_dir
python3 create_tfrecords.py --mode documents --input_dir <base> --name <name> --output_dir <output> --use_gpt2_tokenizer --minimum_size <min>
input_dir : Define la carpeta donde se encuentran sus datos. El script codificará todos los archivos presentes en esta carpeta.name : el nombre de los archivos de salida será name_i.tfrecords donde i es el número del archivo.output_dir : dónde guardar los tfrecordsuse_gpt2_tokenizer : si se debe utilizar el tokenizador HuggingFace GPT2 previamente entrenado, en cuyo caso el separador se establecerá en [50256].encoder_path : si no utiliza el tokenizador gpt2 previamente entrenado, use este indicador para proporcionar una ruta al json del tokenizador generado.separator : Escrito en formato de lista, los tokens separadores que se insertarán entre documentos (por ejemplo, "[0]"). Dependerá de su codificador.minimum_size : El tamaño mínimo (en tokens) que debe tener un documento; de lo contrario, se descarta. Esto es lo que luego determinará su parámetro stitch : stitch * minimum_size siempre debe ser mayor o igual n_ctx (Para más detalles consulte la sección de referencia de parámetros). Para utilizar un conjunto de datos en un modelo, primero debe registrar ese conjunto de datos en la carpeta ./configs/dataset_configs . Primero elija un nombre de archivo con extensión .json . Ese nombre de archivo servirá como identificación del conjunto de datos. La configuración debe completarse de la siguiente manera.
Si tiene un conjunto de datos codificado usando el tokenizador gpt2 previamente entrenado, puede especificarlo de la siguiente manera:
{
"n_vocab" : 50257 ,
"path" : " gs://neo-datasets/openwebtext-documents/openwebtext_*.tfrecords " ,
"eval_path" : " gs://neo-datasets/openwebtext-documents/openwebtext_*.tfrecords " ,
"tokenizer_is_pretrained" : true ,
"tokenizer_path" : " gpt2 "
}o si has entrenado un tokenizador personalizado, así:
{
"n_vocab" : 32768 ,
"path" : " ./path/to/your/*.tfrecords " ,
"eval_path" : " ./path/to/your/eval/*.tfrecords " ,
"tokenizer_path" : " ./path/to/your/byte-level-bpe.tokenizer.json "
} Finalmente, en la configuración de su modelo, agregue el nombre de archivo que creó anteriormente a la matriz de datasets .
El <dataset id> será el nombre del archivo, excluyendo el .json , que creó anteriormente
"datasets": [[<dataset id>, <stitch>, <datatype>, <weight>]] # datasets key defines at run time how each dataset is processed for training
Una vez que haya configurado sus conjuntos de datos, busque una configuración adecuada en /configs .
Aquí usamos un modelo de tamaño GPT3-XL como ejemplo, pero hay muchos más en ./configs , todos los cuales tienen breves resúmenes en la sección Configuraciones disponibles.
Todo lo que necesita hacer es editar la identificación del conjunto de datos como se describe anteriormente y editar model_path (donde se guardarán los registros y puntos de control) para que apunte a un depósito de nube al que tiene acceso de escritura (o ruta local, si usa GPU).
{
"n_head" : 32 ,
"n_vocab" : 50257 ,
"embed_dropout" : 0.1 ,
"lr" : 0.0002 ,
"lr_decay" : " cosine " ,
"warmup_steps" : 3000 ,
"beta1" : 0.9 ,
"beta2" : 0.95 ,
"epsilon" : 1e-8 ,
"opt_name" : " adam " ,
"weight_decay" : 0.1 ,
"train_batch_size" : 512 ,
"attn_dropout" : 0.1 ,
"train_steps" : 286150 ,
"eval_steps" : 0 ,
"predict_steps" : 1 ,
"res_dropout" : 0.1 ,
"eval_batch_size" : 128 ,
"predict_batch_size" : 1 ,
"iterations" : 2500 ,
"n_embd" : 2048 ,
"datasets" : [[ " your_dataset_name " , 25 , " documents_random " , 1.0 ]],
"model_path" : " gs://neo-models/GPT3_XL " ,
"n_ctx" : 2048 ,
"n_layer" : 24 ,
"scale_by_depth" : true ,
"scale_by_in" : false ,
"attention_types" : [[[ " global " ], 24 ]],
"mesh_shape" : " x:128,y:2 " ,
"layout" : " batch:x,memory_length:y,embd:y " ,
"activation_function" : " gelu " ,
"recompute_grad" : true ,
"gradient_clipping" : 1.0 ,
"tokens_per_mb_per_replica" : 2048
} python3 main.py --model <your_config_name> --steps_per_checkpoint <n> --tpu <tpu-name>
tpu : Nombre de la TPU a utilizar.steps_per_checkpoint : la frecuencia en pasos con la que se guardan los puntos de control.--auto_layout y --auto_layout_and_mesh_shape (opcional): deshabilita el entrenamiento y en su lugar genera automáticamente un layout eficiente en memoria (y mesh_shape )gpu_ids : si entrena con GPU, omita el indicador tpu y pase los identificadores de su gpus. En el siguiente ejemplo, entrenamos en 3 GPU, especificando sus ID de dispositivo delimitados por espacios: python3 main.py --model <your_config_name> --steps_per_checkpoint <n> --gpu_ids <device:GPU:0 device:GPU:1>
Tenemos varios tamaños de modelos disponibles, pero algunas de nuestras configuraciones requieren TPU grandes y necesitarán ajustes para ejecutarse en máquinas más pequeñas o GPU. A continuación se muestra una breve guía para cada modelo en el directorio de configuraciones:
HACER
Sacred ayuda a realizar un seguimiento de los experimentos y es mucho más agradable trabajar con él que con el tensorboard.
Para configurar:
Instalar Docker y Docker-compose
Ejecute docker-compose up
Para utilizar:
Asegúrese de que model_dir no tenga ningún registro de métricas (activa las métricas del tensorboard, lo que supone que es una continuación de la ejecución existente). Puedes usar gsutil rm -r ... para eliminar el directorio del modelo
Ejecute python3 run_experiment.py --tpu sometpuhere --model someconfig.json Las opciones son las mismas que main.py
Puede ir a http://server_ip_goes_here:8081/ para ver la descripción general de Omniboard. Si prefiere ver un tablero tensor, el script también activa uno y le asigna automáticamente un puerto. El script debería imprimir el puerto del tensorboard cerca de la parte superior del registro.
Si alguna vez se siente confundido por el conjunto de datos de un archivo de configuración en particular, puede verificar fácilmente los identificadores de token mínimo y máximo con un solo comando. Esto es útil para asegurarse de que el tamaño del vocabulario del modelo sea al menos tan grande como la identificación máxima del token. Tensorflow no generará errores si intenta recopilar datos en una matriz con índices fuera de límites, por lo que debe asegurarse de que el tamaño de su vocabulario sea lo suficientemente grande.
python main --model {config_name} --check_datasetAdemás de poder entrenar GPT de gran tamaño, este repositorio también le permite realizar fácilmente modelado de lenguaje enmascarado (BERT, RoBERTa). Para hacerlo, debes seguir dos pasos adicionales.
Al tokenizar su conjunto de datos, debe reservar una identificación especial para el token [mask] .
En las configuraciones, tendrás que definir dos campos adicionales
"mlm_training" : true , # must be set to true
"mlm_mask_id" : < mask id > # the mask id that you reserved from aboveEso es todo lo que necesitas para entrenar un modelo con el objetivo MLM, bueno para cualquier tipo de datos que hayas codificado correctamente. Si desea modificar los otros hiperparámetros relacionados, continúe leyendo.
"mlm_cls_token_id" : < cls token id > , # auto append specified CLS token id on the left
"mlm_mask_prob" : 0.15 , # the probability of masking a token, defaults to 15%
"mlm_same_token_prob" : 0.10 , # probability of keeping the token the same, defaults to 10%
"mlm_random_token_prob" : 0.10 , # probability of tokens that are replaced with random tokens, 10% was recommended by the BERT paper
"mlm_mask_ignore_ids" : [ < cls token > , < sep token > ] # ignore masking other special tokens, if any Elija una configuración válida de /configs y modifique los parámetros según sea necesario:
n_heads : el número de cabezas de atención.n_embd : Tamaño de las capas ocultas, debe ser divisible por n_heads .n_vocab : Tamaño del vocabulario.embed_dropout , res_dropout , attn_dropout : probabilidad de abandono para incrustaciones de palabras/residuales/atenciónlr : tasa de aprendizajewarmup_steps : número de pasos antes de alcanzar la tasa de aprendizaje completa (rampa lineal de 0 a lr ).lr_decay : cosine o linear .opt_name : adam o adafactor .beta1 , beta2 y epsilon : parámetros del optimizador adam .beta1 , ada_epsilon1 y ada_epsilon2 : parámetros del optimizador adafactor .weight_decay : parámetro de caída de peso; si no está presente, no se usa ninguna caída de peso (se usa la corrección de caída de peso para Adam) (predeterminado: 0,01) (opcional).train_batch_size : tamaño del lote durante el entrenamiento.train_steps : número de pasos de entrenamiento (lotes), establecido en aproximadamente ~1 época por ahora (número total de tokens en su conjunto de datos/número de tokens por lote (= train_batch_size / n_ctx )).eval_steps : Número de pasos a ejecutar para cada evaluación. Establezca en 0 para que no haya evaluación. es decir, después de cada punto de control, el modelo se prueba para eval_stepsiterations : el número de pasos en cola en la TPU debe ser menor que steps_per_checkpoint . (predeterminado: 500)datasets : Lista de conjuntos de datos de tfrecords que se utilizarán. Cada conjunto de datos es una lista con los siguientes parámetros: [train glob , eval glob, stitch, sampling_mode, weight] . Entonces, por ejemplo, para un solo conjunto de datos (tenga en cuenta la lista doble): [["bundestag_*.tfrecords", "", 10, "random_sample", 1.0]]dataset_id : el nombre de un archivo de configuración de conjunto de datos en ./configs/dataset_configsstitch : si se utiliza sampling_mode random_sample , la canalización de entrada muestrea esta cantidad de textos en uno para tomar muestras. Debes seleccionar la puntada para que stitch * minimum_document_length >= n_ctxsampling_mode : chunks (los tfrecords se preprocesan en la longitud correcta y se leen secuencialmente) o documents_random ( stitch cantidad de documentos se concatena y luego se submuestrea aleatoriamente un fragmento n_ctx )weights : cuánto peso relativo debería tener este conjunto de datos en comparación con otrosmodel : Qué modelo entrenar. Actualmente, solo se admite GPT y, de forma predeterminada, si no está presente.model_path : ubicación del depósito de almacenamiento de Google (o ruta local, si se usan GPU) para guardar registros y puntos de control del modelo.n_ctx : Tamaño de la ventana de contexto. El valor predeterminado es 2048n_layer : Número de capas (bloques) en el modelo.scale_by_depth : si es verdadero, la inicialización del peso de las capas se escala según su profundidad como en el documento GPT2.scale_by_in : si es verdadero, la inicialización del peso de las capas se escala según su número de entradas como en el documento GPT2.mesh_shape : una malla es una matriz de procesadores de n dimensiones con dimensiones nombradas que se utilizan para el paralelismo en la biblioteca mesh-tensorflow. Cada tensor se divide uniformemente en las dimensiones de la malla según el diseño (ver más abajo). 'mesh_shape' es la forma de esta matriz y debe ser igual al número de procesadores. por ejemplo, para una TPU v3-128 "mesh_shape": “x:16,y:8”.layout : se coloca un tensor en su malla con una porción en cada procesador. Un "diseño" de tensor es un mapa parcial inyectivo que especifica qué dimensiones del tensor se dividen (uniformemente) en qué dimensiones de la malla. Ninguna dimensión de un tensor puede dividirse en dos dimensiones de su malla y no pueden dividirse dos dimensiones de un tensor en la misma dimensión de su malla. El usuario define un conjunto global de reglas de diseño en forma de pares (nombre-dimensión-tensor, nombre-dimensión-malla). Una dimensión de un tensor se divide en una dimensión de su malla si existe una regla de coincidencia, por ejemplo (para el ejemplo anterior mesh_shape: "layout":"batch:x,heads:y"activation_function : selu (autonormalización) o gelu (utilizada por OA), función de activación utilizada en pases de avance. (predeterminado: gelu)attention_types : el tipo de atención para cada capa en una lista del siguiente formato [[["attention_type"], n_layers]]. por ejemplo, para una red de 12 capas [[["global"], 12]] o [[["local"], 10], [["global"], 2]].linear , global , local o none . Hemos descubierto que una combinación 50/50 de global y linear funciona bien. none le permite crear capas de avance únicamente para modelos de transformadores PAR más eficientes.precision : float32 o bfloat16 .tokens_per_mb_per_replica : si no es Ninguno, dividirá el lote en microlotes más pequeños que contienen tokens tokens_per_mb_per_replica para evitar OOM. Los gradientes se acumulan localmente y se reducen una vez. IMPORTANTE: aquí mb se refiere a minibatch , no a megabyte.Mezcla de expertos
moe_layers : una lista de números de capas a los que agregar una mezcla de capas de expertos. Por ejemplo: [2,4,6,8,10,12] . Experimentalmente hemos encontrado que una capa de moe por cada dos capas de autoatención funciona bien.moe_params : un diccionario de kwargs adicionales para pasar a la capa moe. Por ejemplo, {"moe_dropout_rate": 0.0 }Funciones experimentales
axial_pos_emb_ : si es verdadero, utiliza [incrustación posicional axial](https://arxiv.org/abs/1912.12180.mlp_glu : si es verdadero, utiliza una variante de unidad lineal cerrada de capas de avance.scalenorm : si es verdadero, usa scalenorm en lugar de Layernorm.rezero : si es verdadero, usa rezero en lugar de Layernorm.num_mem_kv : agrega memoria/valores clave del documento de atención total. Param es un int con el número de valores de memoria/clave deseados.macaron : si es verdadero, utiliza un transformador de macaron para cada bloque de capa. Si GPT-Neo le ha resultado útil en su trabajo, puede citar este repositorio como
@software{gpt-neo,
author = {Black, Sid and
Gao, Leo and
Wang, Phil and
Leahy, Connor and
Biderman, Stella},
title = {{GPT-Neo: Large Scale Autoregressive Language
Modeling with Mesh-Tensorflow}},
month = mar,
year = 2021,
note = {{If you use this software, please cite it using
these metadata.}},
publisher = {Zenodo},
version = {1.0},
doi = {10.5281/zenodo.5297715},
url = {https://doi.org/10.5281/zenodo.5297715}
}
El número de versión debe reemplazarse con el número de versión que está utilizando y el año corresponde al lanzamiento de código abierto del proyecto.
Si está específicamente interesado en citar los modelos GPT-Neo entrenados en Pile, le agradeceríamos que también citara
@article{gao2020pile,
title={The Pile: An 800GB Dataset of Diverse Text for Language Modeling},
author={Gao, Leo and Biderman, Stella and Black, Sid and Golding, Laurence and Hoppe, Travis and Foster, Charles and Phang, Jason and He, Horace and Thite, Anish and Nabeshima, Noa and others},
journal={arXiv preprint arXiv:2101.00027},
year={2020}
}
