Startseite>Programmierbezogen>AI-Quellcode
Herunterladen

GPT Neo

* Ab August 2021 wird der Code nicht mehr gepflegt. Es wird hier in archivierter Form für Personen aufbewahrt, die es weiterhin verwenden möchten.

? 1T oder meine Jungs kaputt machen?

Eine Implementierung modell- und datenparalleler GPT3-ähnlicher Modelle unter Verwendung der Mesh-Tensorflow-Bibliothek.

Wenn Sie nur hier sind, um mit unseren vorab trainierten Modellen zu spielen, empfehlen wir Ihnen dringend, die HuggingFace Transformer-Integration auszuprobieren.

Training und Inferenz werden offiziell auf TPU unterstützt und sollten auch auf GPU funktionieren. Dieses Repository wird (größtenteils) archiviert, während wir uns auf unser GPU-spezifisches Repo GPT-NeoX konzentrieren.

Zusätzlich zu den von GPT-3 gebotenen Funktionen bieten wir auch Folgendes an:

  • Lokale Aufmerksamkeit
  • Lineare Aufmerksamkeit
  • Mischung aus Experten
  • Axiale Positionseinbettung

Hinweis: Obwohl Neo technisch gesehen einen Trainingsschritt mit mehr als 200 Milliarden Parametern ausführen kann, ist es in diesen Maßstäben sehr ineffizient. Dies und unter anderem die Tatsache, dass uns viele GPUs zur Verfügung standen, veranlasste uns, die Entwicklung auf GPT-NeoX umzustellen.

Vorab trainierte Modelle

Update 21.03.2021:

Wir sind stolz, zwei vorab trainierte GPT-Neo-Modelle zu veröffentlichen, die auf The Pile trainiert wurden. Die Gewichte und Konfigurationen können kostenlos von the-eye.eu heruntergeladen werden.

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/

Weitere Informationen dazu, wie Sie diese einrichten, finden Sie im Colab-Notizbuch oder lesen Sie den Rest der Readme-Datei durch.

Modellbewertungen

Sprachliches Denken

Modell und Größe Stapel BPB Stapel PPL Wikitext 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 %

Physikalisches und wissenschaftliches Denken

Modell und Größe MathQA PubMedQA Piqa
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 %

Hinweis: Alle Auswertungen wurden mit unserem Auswertungsgeschirr durchgeführt. Einige Ergebnisse für GPT-2 und GPT-3 stimmen nicht mit den in den jeweiligen Artikeln angegebenen Werten überein. Wir prüfen derzeit, warum das so ist, und würden uns über Feedback und weitere Tests unseres Evaluierungsgeschirrs sehr freuen.

Aufstellen 

git clone https://github.com/EleutherAI/GPTNeo
cd GPTNeo
pip3 install -r requirements.txt

Trainingsaufbau

TPUs:

Melden Sie sich bei der Google Cloud Platform an und erstellen Sie einen Speicher-Bucket.

Erstellen Sie Ihre VM über eine Google-Shell ( https://ssh.cloud.google.com/ ) mit ctpu up --vm-only , damit sie eine Verbindung zu Ihrem Google-Bucket und Ihren TPUs herstellen und die Anforderungen mit pip installieren kann (siehe oben). .

Google Colab stellt tpu-v8s kostenlos zur Verfügung, was ausreichen sollte, um unsere Modelle auf GPT3XL-Größen (Parameter 1,5B) zu optimieren. Klicken Sie hier, um unser Beispiel-Colab-Notizbuch durchzugehen.

Ausführlichere Anweisungen finden Sie in unserem Schulungsleitfaden unten.

GPUs:

Sie können GPTNeo auch lokal auf Ihren GPUs trainieren. Dazu können Sie die oben genannten Google-Cloud-Einrichtungsschritte weglassen und das Repo lokal klonen. Gehen Sie den Schulungsleitfaden unten durch. Wenn Sie dann main.py ausführen, müssen Sie einfach das tpu -Flag weglassen und stattdessen GPU-IDs übergeben.

Hinweis: Einige Benutzer haben berichtet, dass sie Schwierigkeiten hatten, MTF dazu zu bringen, ihre GPUs zu erkennen. Weitere Informationen und Anweisungen zur Behebung finden Sie hier.

Text generieren

Sobald Sie über ein trainiertes Modell verfügen oder eines unserer vorab trainierten Modelle heruntergeladen haben, ist das Generieren von Text so einfach wie das Ausführen des Skripts „main.py“ mit aktiviertem Flag --predict . Sie können einen Pfad zu Ihrer Eingabeaufforderungs-TXT-Datei mit dem Flag --prompt übergeben, etwa so: 

python3 main.py --predict --prompt < example_prompt.txt > --tpu < tpu_name > --model < config_name >

oder, wenn GPUs verwendet werden: 

python3 main.py --predict --prompt < example_prompt.txt > --gpu_ids < device:GPU:0 device:GPU: 1> --model < config_name >

Trainingsleitfaden

1. Erstellen Sie Ihren Tokenizer (OPTIONAL)

Wir empfehlen Ihnen, den vorab trainierten GPT2-Tokenizer von Huggingface mit unserem Repo zu verwenden (Anweisungen finden Sie unten). Wenn Sie jedoch ein Modell mit einer anderen Vokabulargröße trainieren möchten, bieten wir Möglichkeiten zum Trainieren Ihres eigenen Tokenizers wie folgt an: 

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'

2. Tokenisierung Ihres Datensatzes

Wenn Sie das Training nur testen möchten, können Sie diesen Schritt überspringen und einige Dummy-Daten wie folgt herunterladen: 

 wget https://storage.googleapis.com/connors-datasets/bundestag/bundestag_0.tfrecords

Kopieren Sie dann die Daten in Ihren Bucket oder bei Verwendung von GPUs in ein lokales Verzeichnis: 

 gsutil cp bundestag_0.tfrecords gs://<your bucket>/

Wenn Sie zum Trainieren Ihre eigenen Daten verwenden, können Sie das Skript data/create_tfrecords.py verwenden, um Ihre Textdaten in tfrecords zu kodieren.

Ihre Daten müssen entweder in Form vieler normaler TXT-Dateien (ein Dokument pro Datei) oder in einem beliebigen von lm_dataformat unterstützten Format vorliegen.

Sie können das Skript ohne Parameter ausführen, um Hilfe für alle Optionen anzuzeigen.

Im Dokumentmodus Jedes Beispiel in den tfrecords ist ein Dokument (variabler Größe). Dies ist mit den Stichprobenmodi documents_fixed und documents_random zu verwenden (weitere Einzelheiten finden Sie im Abschnitt „Parameterreferenz“). Der Dokumentmodus ist der Standardmodus.

Der folgende Befehl tokenisiert alle Dateien in akzeptablen Formaten im Basisverzeichnis mithilfe des gpt2-Tokenizers und speichert sie im Ausgabeverzeichnis 

 python3 create_tfrecords.py --mode documents --input_dir <base> --name <name> --output_dir <output> --use_gpt2_tokenizer --minimum_size <min>
  • input_dir : Definiert den Ordner, in dem sich Ihre Daten befinden. Das Skript kodiert alle in diesem Ordner vorhandenen Dateien.
  • name : Der Name der Ausgabedateien lautet name_i.tfrecords wobei i die Nummer der Datei ist.
  • output_dir : Wo sollen die Tfrecords gespeichert werden?
  • use_gpt2_tokenizer : Ob der vorab trainierte HuggingFace GPT2-Tokenizer verwendet werden soll. In diesem Fall wird das Trennzeichen auf [50256] gesetzt.
  • encoder_path : Wenn Sie nicht den vorab trainierten gpt2-Tokenizer verwenden, verwenden Sie dieses Flag, um einen Pfad zu Ihrem generierten Tokenizer-JSON bereitzustellen.
  • separator : Im Listenformat geschrieben, die Trennzeichen, die zwischen Dokumenten eingefügt werden sollen (z. B. „[0]“). Hängt von Ihrem Encoder ab.
  • minimum_size : Die Mindestgröße (in Token), die ein Dokument haben muss, andernfalls wird es verworfen. Dies bestimmt später Ihren stitch : stitch * minimum_size muss immer größer oder gleich n_ctx sein (Weitere Einzelheiten finden Sie im Abschnitt „Parameterreferenz“).

4. Verwenden eines Datensatzes in einem Modell

Um einen Datensatz in einem Modell zu verwenden, müssen Sie diesen Datensatz zunächst im Ordner ./configs/dataset_configs registrieren. Wählen Sie zunächst einen Dateinamen mit der Erweiterung .json . Dieser Dateiname dient als Datensatzidentifikation. Die Konfiguration sollte wie folgt ausgefüllt werden.

Wenn Sie einen Datensatz haben, der mit dem vorab trainierten gpt2-Tokenizer codiert wurde, können Sie dies wie folgt angeben: 

{
    "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 "
}

oder wenn Sie einen benutzerdefinierten Tokenizer trainiert haben, etwa so: 

{
    "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 "
}

Fügen Sie schließlich in Ihrer Modellkonfiguration den Dateinamen, den Sie oben erstellt haben, zum datasets Array hinzu.

Die <dataset id> ist der Dateiname, mit Ausnahme der .json , die Sie oben erstellt haben 

 "datasets": [[<dataset id>, <stitch>, <datatype>, <weight>]] # datasets key defines at run time how each dataset is processed for training

5. Wählen Sie eine Modellkonfiguration

Sobald Sie Ihre Datensätze eingerichtet haben, suchen Sie in /configs nach einer geeigneten Konfiguration.

Hier verwenden wir als Beispiel ein GPT3-XL-Modell, aber es gibt noch viele weitere in ./configs , die alle im Abschnitt „Verfügbare Konfigurationen“ kurze Zusammenfassungen enthalten.

Sie müssen lediglich die Datensatz-ID wie oben beschrieben bearbeiten und model_path (wo Protokolle und Prüfpunkte gespeichert werden) bearbeiten, um auf einen Cloud-Bucket zu verweisen, auf den Sie Schreibzugriff haben (oder auf einen lokalen Pfad, wenn Sie GPUs verwenden). 

{
    "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
}

6. Lauftraining 

 python3 main.py --model <your_config_name> --steps_per_checkpoint <n> --tpu <tpu-name>
  • tpu : Name der zu verwendenden TPU.
  • steps_per_checkpoint : Die Häufigkeit in Schritten, mit der Prüfpunkte gespeichert werden sollen.
  • --auto_layout und --auto_layout_and_mesh_shape (Optional): Deaktivieren Sie das Training und generieren Sie stattdessen automatisch ein speichereffizientes layout (und mesh_shape )
  • gpu_ids : Wenn Sie mit GPUs trainieren, lassen Sie das tpu -Flag weg und übergeben Sie die IDs Ihres GPUs. Im folgenden Beispiel trainieren wir auf drei GPUs und geben ihre durch Leerzeichen getrennten Geräte-IDs an: 
 python3 main.py --model <your_config_name> --steps_per_checkpoint <n> --gpu_ids <device:GPU:0 device:GPU:1>

Verfügbare Konfigurationen

Wir haben mehrere Modellgrößen zur Verfügung, aber einige unserer Konfigurationen erfordern große TPUs und müssen optimiert werden, um auf kleineren Maschinen oder GPUs zu laufen. Nachfolgend finden Sie eine kurze Anleitung zu jedem Modell im configs-Verzeichnis:

TODO

Zusätzliche Funktionen:

Training (mit Sacred)

Sacred hilft beim Verfolgen von Experimenten und ist viel angenehmer zu verwenden als Tensorboard.

Zum Einrichten:

  1. Installieren Sie Docker und Docker-compose

  2. Führen Sie docker-compose up

Zur Verwendung:

  1. Stellen Sie sicher, dass „model_dir“ keine Metrikprotokolle enthält (es löst die Metrikdaten für Tensorboard aus, was davon ausgeht, dass es sich um eine Fortsetzung des vorhandenen Laufs handelt). Sie können gsutil rm -r ... verwenden, um das Modellverzeichnis zu löschen

  2. Führen Sie python3 run_experiment.py --tpu sometpuhere --model someconfig.json aus. Die Optionen sind die gleichen wie bei main.py

  3. Sie können zu http://server_ip_goes_here:8081/ gehen, um die Omniboard-Übersicht anzuzeigen. Wenn Sie lieber ein Tensorboard sehen möchten, startet das Skript auch eines und weist ihm automatisch einen Port zu. Das Skript sollte den Tensorboard-Port oben im Protokoll ausdrucken.

Blick auf einen Datensatz

Wenn Sie jemals durch den Datensatz einer bestimmten Konfigurationsdatei verwirrt sind, können Sie die minimalen und maximalen Token-IDs ganz einfach mit einem einzigen Befehl überprüfen. Dies ist nützlich, um sicherzustellen, dass die Vokabulargröße des Modells mindestens so groß ist wie die maximale Token-ID. Tensorflow macht keinen Fehler, wenn Sie versuchen, eine Matrix mit Indizes außerhalb der Grenzen zu erfassen. Sie müssen daher sicherstellen, dass Ihr Vokabular ausreichend groß ist. 

python main --model {config_name} --check_dataset

Maskierte Sprachmodellierung

Neben der Möglichkeit, große GPTs zu trainieren, ermöglicht Ihnen dieses Repository auch die einfache Durchführung maskierter Sprachmodellierung (BERT, RoBERTa). Dazu müssen Sie zwei zusätzliche Schritte ausführen.

  1. Bei der Tokenisierung Ihres Datensatzes müssen Sie eine spezielle ID für das [mask] -Token reservieren.

  2. In den Konfigurationen müssen Sie zwei zusätzliche Felder definieren 

 "mlm_training" : true ,                           # must be set to true
"mlm_mask_id" : < mask id >                        # the mask id that you reserved from above

Das ist alles, was Sie brauchen, um ein Modell mit dem MLM-Ziel zu trainieren, und zwar für alle Arten von Daten, die Sie ordnungsgemäß codiert haben. Wenn Sie die anderen verwandten Hyperparameter optimieren möchten, lesen Sie bitte weiter. 

 "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

Parameterreferenz

Wählen Sie eine gültige Konfiguration aus /configs aus und passen Sie die Parameter nach Bedarf an:

  • n_heads : Die Anzahl der Aufmerksamkeitsköpfe.
  • n_embd : Größe der verborgenen Ebenen, muss durch n_heads teilbar sein.
  • n_vocab : Vokabelgröße.
  • embed_dropout , res_dropout , attn_dropout : Dropout-Wahrscheinlichkeit für Worteinbettung/Residuen/Aufmerksamkeit
  • lr : Lernrate
  • warmup_steps : Anzahl der Schritte, bevor die volle Lernrate erreicht ist (lineare Rampe von 0 bis lr ).
  • lr_decay : cosine oder linear .
  • opt_name : adam oder adafactor .
  • beta1 , beta2 und epsilon : adam -Optimierungsparameter.
  • beta1 , ada_epsilon1 und ada_epsilon2 : Parameter adafactor -Optimierers.
  • weight_decay : Gewichtsabfallparameter, falls nicht vorhanden, wird kein Gewichtsabfall verwendet (der Gewichtsabfall-Fix für Adam wird verwendet) (Standard: 0,01) (optional).
  • train_batch_size : Batchgröße während des Trainings.
  • train_steps : Anzahl der Trainingsschritte (Batches), vorerst auf ungefähr ~1 Epoche eingestellt (Gesamtzahl der Token in Ihrem Datensatz / Anzahl der Token pro Batch (= train_batch_size / n_ctx )).
  • eval_steps : Anzahl der Schritte, die für jede Bewertung ausgeführt werden sollen. Für keine Auswertung auf 0 setzen. Das heißt, nach jedem Prüfpunkt wird das Modell auf eval_steps getestet
  • iterations : Anzahl der Schritte, die in der Warteschlange der TPU stehen, muss kleiner sein als steps_per_checkpoint . (Standard: 500)
  • datasets : Liste der zu verwendenden Tfrecords-Datensätze. Jeder Datensatz ist eine Liste mit den folgenden Parametern: [train glob , eval glob, stitch, sampling_mode, weight] . Also zum Beispiel für einen einzelnen Datensatz (beachten Sie die doppelte Liste): [["bundestag_*.tfrecords", "", 10, "random_sample", 1.0]]
    • dataset_id : Der Name einer Datensatzkonfigurationsdatei in ./configs/dataset_configs
    • stitch : Wenn sampling_mode random_sample verwendet wird, sticht die Eingabepipeline diese Textmenge in einen Text zusammen, aus dem eine Stichprobe erstellt werden soll. Sie müssen den Stich so auswählen, dass stitch * minimum_document_length >= n_ctx
    • sampling_mode : chunks (tfrecords werden auf die richtige Länge vorverarbeitet und nacheinander gelesen) oder documents_random ( stitch Anzahl von Dokumenten wird verkettet und dann wird ein n_ctx Chunk zufällig unterabgetastet)
    • weights : Wie viel relatives Gewicht dieser Datensatz im Vergleich zu anderen haben sollte
  • model : Welches Modell trainiert werden soll. Derzeit wird nur GPT unterstützt. Falls nicht vorhanden, wird dies standardmäßig verwendet.
  • model_path : Speicherort des Google-Speicher-Buckets (oder lokaler Pfad, wenn GPUs verwendet werden), um Modellprüfpunkte und Protokolle zu speichern.
  • n_ctx : Größe des Kontextfensters. Der Standardwert ist 2048
  • n_layer : Anzahl der Schichten (Blöcke) im Modell.
  • scale_by_depth : Wenn true, wird die Gewichtsinitialisierung von Ebenen wie im GPT2-Papier nach ihrer Tiefe skaliert.
  • scale_by_in : Wenn „true“, wird die Gewichtsinitialisierung von Ebenen anhand ihrer Anzahl von Eingaben skaliert, wie im GPT2-Papier.
  • mesh_shape : Ein Mesh ist ein n-dimensionales Array von Prozessoren mit benannten Dimensionen, die für Parallelität in der Mesh-Tensorflow-Bibliothek verwendet werden. Jeder Tensor ist entsprechend dem Layout gleichmäßig auf die Netzdimensionen aufgeteilt (siehe unten). „mesh_shape“ ist die Form dieses Arrays und muss der Anzahl der Prozessoren entsprechen. z. B. für eine v3-128-TPU „mesh_shape“: „x:16,y:8“.
  • layout : Ein Tensor wird auf seinem Netz mit einem Slice auf jedem Prozessor angeordnet. Ein Tensor-„Layout“ ist eine injektive Teilkarte, die angibt, welche Dimensionen des Tensors (gleichmäßig) auf welche Dimensionen des Netzes aufgeteilt sind. Keine Dimension eines Tensors darf auf zwei Dimensionen seines Netzes aufgeteilt werden, und keine zwei Dimensionen eines Tensors dürfen auf dieselbe Dimension seines Netzes aufgeteilt werden. Der Benutzer definiert einen globalen Satz von Layoutregeln in Form von (Tensor-Dimensionsname, Mesh-Dimensionsname)-Paaren. Eine Dimension eines Tensors wird über eine Dimension seines Netzes aufgeteilt, wenn es eine passende Regel gibt, z. B. (für das obige Beispiel mesh_shape: „layout“: „batch:x,heads:y“
  • activation_function : selu (selbstnormalisierend) oder gelu (von OA verwendet), Aktivierungsfunktion, die in Feed-Forward-Durchgängen verwendet wird. (Standard: gelu)
  • attention_types : der Typ der Aufmerksamkeit für jede Ebene in einer Liste im folgenden Format [[["attention_type"], n_layers]]. zB für ein 12-Schichten-Netz [[["global"], 12]] oder [[["local"], 10], [["global"], 2]].
    • Wählen Sie aus: linear , global , local oder none . Wir haben festgestellt, dass eine 50/50-Mischung aus global und linear gut funktioniert. none können Sie reine Feed-Forward-Ebenen für effizientere PAR-Transformer-Modelle erstellen.
  • precision : float32 oder bfloat16 .
  • tokens_per_mb_per_replica : Wenn nicht „Keine“, wird der Stapel in kleinere Mikrobatches aufgeteilt, tokens_per_mb_per_replica Tokens enthalten, um OOMs zu vermeiden. Gradienten werden lokal akkumuliert und einmalig reduziert. WICHTIG: MB bezieht sich hier auf Minibatch und nicht auf Megabyte.

Mischung aus Experten

  • moe_layers : Eine Liste von Ebenennummern, an die eine Mischung aus Expertenebenen angehängt werden soll. ZB: [2,4,6,8,10,12] . Wir haben experimentell herausgefunden, dass eine MoE-Schicht für jeweils zwei Selbstaufmerksamkeitsschichten gut funktioniert.
  • moe_params : ein Wörterbuch zusätzlicher Kwargs, die an die Moe-Ebene übergeben werden sollen. EG {"moe_dropout_rate": 0.0 }

Experimentelle Funktionen

  • axial_pos_emb_ : Wenn wahr, wird [axiale Positionseinbettung] verwendet(https://arxiv.org/abs/1912.12180.
  • mlp_glu : Wenn true, wird eine Gated-Linear-Unit-Variante von Feed-Forward-Layern verwendet.
  • scalenorm : Wenn true, wird Scalenorm anstelle von Layernorm verwendet.
  • rezero : Wenn true, wird rezero anstelle von Layernorm verwendet.
  • num_mem_kv : Fügt Speicher-/Schlüsselwerte aus dem All-Attention-Paper hinzu. Param ist ein int mit der Anzahl der gewünschten Mem-/Schlüsselwerte.
  • macaron : Wenn wahr, wird für jeden Ebenenblock ein Macaron-Transformator verwendet.

TODO:

  • Dokumentation abschließen
  • Konfigurationen aktualisieren

Unter Berufung auf GPT-Neo

Wenn Sie GPT-Neo bei Ihrer Arbeit als hilfreich empfunden haben, können Sie dieses Repository als zitieren 

 @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}
}

Die Versionsnummer sollte durch die von Ihnen verwendete Versionsnummer ersetzt werden, und das Jahr entspricht der Open-Source-Veröffentlichung des Projekts.

Wenn Sie speziell daran interessiert sind, die auf dem Pile trainierten GPT-Neo-Modelle zu zitieren, würden wir uns freuen, sie ebenfalls zu zitieren 

 @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}
}
Expandieren
Zusätzliche Informationen
Ähnliche Anwendungen
Empfohlen für Sie
Ähnliche Nachrichten Alle