minGPT

mingpt

Une réimplémentation PyTorch de GPT, à la fois formation et inférence. minGPT essaie d'être petit, propre, interprétable et éducatif, car la plupart des implémentations de modèles GPT actuellement disponibles peuvent être un peu tentaculaires. GPT n'est pas un modèle compliqué et cette implémentation représente à juste titre environ 300 lignes de code (voir mingpt/model.py). Tout ce qui se passe, c'est qu'une séquence d'indices alimente un transformateur et qu'une distribution de probabilité sur l'index suivant de la séquence en sort. La majorité de la complexité consiste simplement à être intelligent avec le traitement par lots (à la fois entre les exemples et sur la longueur de la séquence) pour plus d'efficacité.

note (janvier 2023) : bien que je puisse continuer à accepter et modifier certains détails, minGPT est dans un état semi-archivé. Pour des développements plus récents, voir ma réécriture nanoGPT. Fondamentalement, minGPT a été référencé dans une grande variété d'endroits (ordinateurs portables, blogs, cours, livres, etc.), ce qui m'a rendu moins disposé à apporter les changements plus importants que je souhaitais apporter pour faire avancer le code. Je voulais aussi changer un peu de direction, d'une concentration uniquement sur l'éducation à quelque chose qui reste simple et piratable mais qui a du mordant (reproduit les références de l'industrie de taille moyenne, accepte certains compromis pour gagner en efficacité d'exécution, etc.).

La bibliothèque minGPT est composée de trois fichiers : mingpt/model.py contient la définition réelle du modèle Transformer, mingpt/bpe.py contient un encodeur de paires d'octets légèrement refactorisé qui traduit entre le texte et les séquences d'entiers exactement comme OpenAI l'a fait dans GPT, mingpt/trainer. py est le code passe-partout PyTorch (indépendant de GPT) qui entraîne le modèle. Ensuite, il existe un certain nombre de démos et de projets qui utilisent la bibliothèque dans le dossier projects :

projects/adder forme un GPT à partir de zéro pour ajouter des nombres (inspiré de la section d'addition dans l'article GPT-3)
projects/chargpt entraîne un GPT à être un modèle de langage au niveau des caractères sur un fichier texte d'entrée
demo.ipynb montre une utilisation minimale du GPT et Trainer dans un format notebook sur un exemple de tri simple
generate.ipynb montre comment charger un GPT2 pré-entraîné et générer du texte à l'aide d'une invite

Installation de la bibliothèque

Si vous souhaitez import mingpt dans votre projet :

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

Usage

Voici comment instancier un GPT-2 (version de paramètres 124 M) :

 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 )

Et voici comment vous l'entraîneriez :

 # 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 ()

Voir demo.ipynb pour un exemple plus concret.

Tests unitaires

La couverture n’est pas encore très étonnante, mais :

 python -m unittest discover tests

toutes les choses

ajouter une démo de réglage fin gpt-2 sur un fichier texte arbitraire donné
ajouter une démo d'agent de dialogue
meilleurs documents de résultats pour les projets existants (additionneur, chargpt)
ajouter une précision mixte et des goodies de mise à l'échelle de formation associés
support de formation distribué
reproduire certains benchmarks dans des projets/, par exemple text8 ou autre modélisation de langage
journalisation appropriée au lieu d'imprimer la déclaration heure amateur haha
je devrais probablement avoir un fichier exigences.txt...
il devrait être possible de charger de nombreux autres poids de modèle autres que simplement gpt2-*

Références

Code:

openai/gpt-2 a la définition du modèle dans TensorFlow, mais pas le code de formation
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 fonctions volumineuses contiennent 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

Pré-entraînement génératif à partir de pixels (Image GPT)

Lorsque nous travaillons avec des images, nous choisissons la permutation d'identité πi = i pour 1 ≤ i ≤ n, également connue sous le nom d'ordre raster.
nous créons notre propre palette de couleurs 9 bits en regroupant les valeurs de pixels (R, V, B) en utilisant k-means avec k = 512.
Notre plus grand modèle, iGPT-XL, contient L = 60 couches et utilise une taille d'intégration de d = 3 072 pour un total de 6,8 B paramètres.
Notre prochain plus grand modèle, iGPT-L, est essentiellement identique à GPT-2 avec L = 48 couches, mais contient une taille d'intégration légèrement plus petite de d = 1 536 (contre 1 600) pour un total de 1,4 B de paramètres.
Nous utilisons le même code de modèle que GPT-2, sauf que nous initialisons les poids de manière dépendante des couches comme dans Sparse Transformer (Child et al., 2019) et initialisons à zéro toutes les projections produisant des logits.
Nous formons également iGPT-M, un modèle de paramètres 455M avec L = 36 et d = 1024
iGPT-S, un modèle de paramètres 76M avec L = 24 et d = 512 (d'accord, et combien de têtes ? on dirait que le code Github revendique 8)
Lors de la pré-entraînement d'iGPT-XL, nous utilisons une taille de lot de 64 et nous entraînons pour 2 millions d'itérations, et pour tous les autres modèles, nous utilisons une taille de lot de 128 et nous entraînons pour 1 million d'itérations.
Adam avec β1 = 0,9 et β2 = 0,95
Le taux d'apprentissage s'échauffe pendant une époque, puis diminue jusqu'à 0
Nous n’avons pas utilisé la diminution du poids car l’application d’une légère diminution du poids de 0,01 n’a pas modifié la qualité de la représentation.
iGPT-S lr 0,003
Aucun décrochage n'est utilisé.