minGPT TF

minGPT-TF

Une réimplémentation TensorFlow de mingpt

Carnets

play_math.ipynb et play_char.ipynb formés dans colab. Des liens se trouvent en haut de chaque cahier pour entraîner le modèle sur colab. play_char.ipynb notebook batch_size est réduit pour s'adapter à la mémoire GPU de Colab. Modifiez les paramètres en fonction de la mémoire GPU.

minGPT – Lisez-moi

Une réimplémentation PyTorch de la formation GPT. minGPT essaie d'être petit, propre, interprétable et éducatif, car la plupart de ceux actuellement disponibles sont un peu tentaculaires. GPT n'est pas un modèle compliqué et cette implémentation comprend à juste titre environ 300 lignes de code, y compris un passe-partout et un module d'auto-attention causale personnalisé totalement inutile. Quoi qu'il en soit, tout ce qui se passe, c'est qu'une séquence d'indices entre dans une séquence de blocs de transformateur et qu'une distribution de probabilité de l'indice suivant en sort. Le reste de la complexité consiste simplement à être intelligent avec le traitement par lots (à la fois sur les exemples et sur la longueur de la séquence) afin que la formation soit efficace.

La "bibliothèque" principale minGPT (hah) est composée de deux fichiers : mingpt/model.py contient la définition réelle du modèle Transformer et mingpt/trainer.py est un passe-partout PyTorch (indépendant de GPT) qui entraîne le modèle. Les cahiers Jupyter ci-joints montrent ensuite comment la « bibliothèque » (hah) peut être utilisée pour entraîner des modèles de séquence :

• play_math.ipynb entraîne un GPT axé sur l'addition (inspiré de la section sur l'addition dans l'article GPT-3)
• play_char.ipynb entraîne un GPT pour qu'il soit un modèle de langage au niveau des caractères sur du texte arbitraire, similaire à mon ancien char-rnn mais avec un transformateur au lieu d'un RNN
• play_words.ipynb une version BPE qui n'existe pas encore

Avec un encodeur bpe, une formation distribuée et peut-être fp16, cette implémentation pourrait être capable de reproduire les résultats GPT-1/GPT-2, même si je n'ai pas essayé $$$. GPT-3 est probablement hors de portée car je crois comprendre qu'il ne rentre pas dans la mémoire du GPU et nécessite un traitement parallèle au modèle plus soigné.

Exemple d'utilisation

Ce code est assez simple pour être hacké en ligne, pas "utilisé", mais l'API actuelle ressemble à ceci :

 # 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

Références

Code:

• openai/gpt-2 a le modèle mais pas le code de formation, et dans TensorFlow
• openai/image-gpt a des modifications plus modernes de type gpt-3 dans son code, bonne référence également
• huggingface/transformers a un exemple de modélisation du langage. Il est complet mais par conséquent quelque peu difficile à retracer. Par exemple, certaines grandes fonctions ont jusqu'à 90 % de code inutilisé derrière diverses instructions de branchement qui n'est pas utilisé dans le paramètre par défaut de la modélisation de langage simple.

Articles + quelques notes d'implémentation :

Améliorer la compréhension du langage grâce à la pré-formation générative (GPT-1)

• Notre modèle suit en grande partie le travail original du transformateur
• Nous avons formé un transformateur uniquement décodeur à 12 couches avec des têtes d'auto-attention masquées (768 états dimensionnels et 12 têtes d'attention). Pour les réseaux à action directe en fonction de la position, nous avons utilisé 3 072 états internes dimensionnels.
• Taux d'apprentissage maximum d'Adam de 2,5e-4. (plus tard, GPT-3 pour cette taille de modèle utilise 6e-4)
• Désintégration LR : augmentée linéairement à partir de zéro au cours des 2000 premières mises à jour et recuite à 0 en utilisant un programme cosinus
• Nous nous entraînons pendant 100 époques sur des mini-lots de 64 séquences contiguës échantillonnées au hasard de 512 jetons.
• Étant donné que layernorm est largement utilisé dans tout le modèle, une simple initialisation du poids de N (0, 0,02) était suffisante.
• Vocabulaire de codage par paires d'octets (BPE) avec 40 000 fusions
• résiduels, intégrations et abandons d'attention avec un taux de 0,1 pour la régularisation.
• version modifiée de la régularisation L2 proposée dans (37), avec w = 0,01 sur tous les poids sans biais ou gain
• Pour la fonction d'activation, nous avons utilisé l'unité linéaire d'erreur gaussienne (GELU).
• Nous avons utilisé des plongements de positions apprises au lieu de la version sinusoïdale proposée dans l'ouvrage original.
• Pour le réglage fin : nous ajoutons des abandons au classificateur avec un taux de 0,1. taux d'apprentissage de 6,25e-5 et taille de lot de 32,3 époques. Nous utilisons un programme de décroissance du taux d'apprentissage linéaire avec un échauffement supérieur à 0,2 % de l'entraînement. λ a été fixé à 0,5.
• Le modèle GPT-1 est composé de 12 couches et d_model 768, ~ 117 M de paramètres

Les modèles linguistiques sont des apprenants multitâches non supervisés (GPT-2)

• LayerNorm a été déplacé vers l'entrée de chaque sous-bloc, semblable à un réseau résiduel de pré-activation
• une normalisation de couche supplémentaire a été ajoutée après le bloc final d'auto-attention.
• une initialisation modifiée qui prend en compte l'accumulation sur le chemin résiduel avec la profondeur du modèle est utilisée. Nous mettons à l'échelle les poids des couches résiduelles à l'initialisation par un facteur de 1/√N où N est le nombre de couches résiduelles. (bizarre parce que dans leur code publié, je ne trouve qu'une utilisation simple de l'ancien 0.02... dans leur version d'image-gpt, je l'ai trouvé utilisé pour c_proj, et même alors uniquement pour attn, pas pour mlp. hein. https : //github.com/openai/image-gpt/blob/master/src/model.py)
• le vocabulaire est étendu à 50 257
• augmenter la taille du contexte de 512 à 1024 jetons
• une taille de lot plus grande de 512 est utilisée
• GPT-2 utilisait 48 couches et d_model 1600 (contre 12 couches d'origine et d_model 768). ~1,542B de paramètres

Les modèles linguistiques sont des apprenants peu nombreux (GPT-3)

• GPT-3 : 96 couches, 96 têtes, avec d_model de 12 288 (paramètres 175B).
• De type GPT-1 : 12 couches, 12 têtes, d_model 768 (125M)
• Nous utilisons le même modèle et la même architecture que GPT-2, y compris l'initialisation modifiée, la pré-normalisation et la tokenisation réversible qui y sont décrites.
• nous utilisons une alternance de modèles d'attention clairsemés, denses et localement regroupés dans les couches du transformateur, similaires au Sparse Transformer
• nous avons toujours la couche feedforward quatre fois la taille de la couche goulot d'étranglement, dff = 4 ∗ dmodel
• tous les modèles utilisent une fenêtre contextuelle de nctx = 2048 jetons.
• Adam avec β1 = 0,9, β2 = 0,95 et eps = 10−8
• Tous les modèles utilisent une diminution de poids de 0,1 pour fournir une petite quantité de régularisation. (REMARQUE : GPT-1 a utilisé 0,01, je crois, voir ci-dessus)
• coupez la norme globale du dégradé à 1,0
• Échauffement linéaire LR sur les 375 premiers millions de jetons. Utilisez ensuite la désintégration du cosinus pour un taux d'apprentissage jusqu'à 10 % de sa valeur, soit plus de 260 milliards de jetons.
• augmentez progressivement la taille du lot de manière linéaire d'une petite valeur (32 000 jetons) à la valeur totale sur les 4 à 12 premiers milliards de jetons de formation, en fonction de la taille du modèle.
• une fenêtre de contexte temporelle complète de taille 2048 est toujours utilisée, avec un délimiteur de jeton spécial FIN DE DOCUMENT

Licence

MIT