tinystories wrappers

Analyse mécaniquement des effets de l'affiche sur les tâches définies de manière procédurale

Il s'agit du code pour les expériences de tinystories de l'article: analyse mécaniquement les effets de la réglage fin sur les tâches définies de manière procédurale. Le code est basé sur les super https://github.com/karpathy/llama2.c.

Installation et configuration

Pour installer, cloner le référentiel, faire un ENV / WOOK virtuel, et pip install -r requirements.txt .

Pour télécharger l'ensemble de données, exécutez python tinystories.py download --data_cache_dir <path_to_data_dir> , avec <path_to_data_dir> un chemin où vous pouvez stocker l'ensemble de données téléchargé et des versions tokenisées.

Le code génère des ensembles de données et les tokenise avant de s'entraîner, en utilisant python tinystories pretokenize <args> . Pour spécifier les différents ensembles de données de pré-formation et de réglage fin (par exemple, la suppression et la récupération), nous utilisons différents arguments de filtrage à la commande pretokenize .

Il y a aussi une commande pour former un tokenizer, en utilisant python tinystories train_vocab . Il s'agit de deux fichiers, tok8192.model et tok8192.vocab . Je l'ai déjà fait et le tokenizer est sur data/tok8192.{model/vocab} . Vous devez déplacer ces fichiers vers le <path_to_data_dir> que vous utiliserez pour vos expériences.

Assurez-vous de vous connecter à wandb afin que vos expériences y soient enregistrées.

Génération d'ensembles de données

Comme mentionné ci-dessus, chaque protocole de réglage fin est contrôlé par un ensemble de données, que nous générons avant le début de la formation. À toute formation, nous avons d'abord besoin de générer les ensembles de données correspondants à l'aide python tinystories pretokenize ... :

usage: tinystories.py [-h] [--vocab_size VOCAB_SIZE] [--data_cache_dir DATA_CACHE_DIR] [--filtering FILTERING] [--mix_match MIX_MATCH]
                      [--adversarial_training ADVERSARIAL_TRAINING] [--refusal REFUSAL] [--dataset_name DATASET_NAME]
                      {download,pretokenize,train_vocab}

positional arguments:
  {download,pretokenize,train_vocab}

options:
  -h, --help            show this help message and exit
  --vocab_size VOCAB_SIZE
                        pretokenization vocab size. 0 = use Llama 2 tokenizer.
  --data_cache_dir DATA_CACHE_DIR
                        Adjust data cache dir
  --filtering FILTERING
                        How to filter data
  --mix_match MIX_MATCH
                        How to mix_match sample
  --adversarial_training ADVERSARIAL_TRAINING
                        How to adversarially sample
  --refusal REFUSAL     Which features to refusal-train on
  --dataset_name DATASET_NAME
                        dataset name

Les arguments filtering , mix_match , adversarial_training et refusal prennent un format spécifique:

• filtering : --filtering=<FEATURE>=<VALUE>,<FEATURE>!=<VALUE>,...
• mix_match : --mix_match=<FEATURE>:<VALUE1>=<VALUE2>,... remplace <VALUE1> par <VALUE2> pour <FEATURE> .
• adversarial_training : --adversarial_training=<FEATURE>=<VALUE>:<PROBABILITY>,... ajoute <VALUE> à <FEATURE> avec <PROBABILITY> la probabilité.
• refusal : --refusal=<FEATURE>=<VALUE>:<PROBABILITY>,... définit l'histoire sur un refus et ajoute <VALUE> à <FEATURE> avec <PROBABILITY> probabilité.

La génération d'un ensemble de données prend environ 10 minutes en raison de la tokenisation. Si un nom de jeu de données n'est pas passé, un est généré à partir des fonctionnalités fournies et que l'ensemble de données est stocké dans DATA_CACHE_DIR/<dataset_name> .

Pour générer tous les ensembles de données nécessaires pour les expériences de suppression et de récupération pour une fonctionnalité donnée, utilisez dataset_gen/tw_fs.sh , mais modifiez DATA_CACHE_DIR dans le répertoire correct et ajustez FEATURE_DELETE et FEATURE_IRRELEVANT si nécessaire.

Téléchargement des modèles déjà formés

Vous pouvez télécharger les modèles de recouvrement de base, post-délétion et post-recouvre

Vous devez extraire les modèles de ce fichier, puis consulter Model_Names.md pour voir quel modèle est lequel.

Le jeton de ces modèles est dans tokenizers/ . Vous devrez copier ces fichiers sur DATA_CACHE_DIR que vous utilisez pour les points de contrôle du modèle.

Formation en cours d'exécution

Pour exécuter la formation, utilisez python train.py <args> . Vous pouvez créer une configuration de formation spécifique en copiant un fichier dans configs et en ajustant les arguments à vos besoins, et les arguments peuvent également être remplacés sur la ligne de commande, comme ainsi:

python train.py configs/base30M.py --batch_size=32 --lr=1e-4

Les arguments doivent utiliser = et non des espaces.

Cette configuration vous permet de créer un fichier de configuration pour un ensemble d'expériences ou un balayage, puis de passer uniquement les arguments qui varient avec les expériences (IE Base Model, Learning Rate, DataSet, etc.) sur la ligne de commande.

Toutes ces commandes enregistreront automatiquement les statistiques et les générations à wandb , alors assurez-vous que vous êtes connecté à cela.

Commande d'exemple de pré-formation

python train.py configs/base91M.py --batch_size=256 --dropout=0.1 --gradient_accumulation_steps=2 --learning_rate=0.0001 --max_iters=100000 --max_seq_len=512

Exemple de réglage fin

Effacement:

python train.py configs/base91M_tw_delete_no_lrs.py --dataset_name=filter-adv-Twist --learning_rate=1e-05

Récupération:

python train.py configs/base91M_tw_recovery_no_lrs.py --model_dir=/cache/tinystories/base91M-train-2023_10_06_15_15_49_074/out

Balayage

J'ai lancé des expériences sous le nom wandb . Vous pouvez voir des exemples de configurations de balayage pour la suppression et la récupération en sweeps/*.yaml . Créez un balayage avec wandb sweep -p tinystories-uft -e ucl-dar sweeps/<sweep.yaml> , puis dans quel script de soumission que vous utilisez, exécutez wandb agent <sweep_id> --count 1 (vous avez besoin --count 1 Si vous utilisez Slurm / etc.

Bref guide de formation .

Voir le script Train.py pour des lancements plus exotiques et des remplacements hyperparamètres. Voici un bref guide pour définir les paramètres. Regardez la table à la toute fin du papier chinchilla pour comprendre comment les paramètres du transformateur (DIM, n_layers, n_heads) se développent ou se rétrécissent ensemble. Extrapoler / interpoler ce modèle pour obtenir des transformateurs plus gros ou plus petits. Définissez la longueur du contexte maximum comme vous le souhaitez, selon le problème: il devrait s'agir du nombre maximal de jetons qui comptent pour prédire le jet suivant. Eg Llama 2 utilise 2048. Ensuite, vous voulez que la taille totale du lot par mise à jour (imprimé par le script car "les jetons par itération seront:") se situe quelque part d'environ 100K jetons pour les applications de taille moyenne. Pour les applications minuscules, elle pourrait être plus faible, pour une formation importante (par exemple GPTS / Llamas), il est généralement ~ 0,5 m, ou même plus. Vous y arrivez en maximisant d'abord le Batch_Size à ce que votre système permet (par exemple, le mien était 16 dans une récente exécution car après cela, mon GPU manque de mémoire), puis vous voulez augmenter Gradient_Accumulation_steps pour être aussi élevé que nécessaire pour atteindre la taille totale du lot de ~ 100k. Enfin, vous voulez régler votre apprentissage_rate (LR). Vous voulez que cela soit aussi élevé que votre entraînement le permet. De très petits réseaux peuvent s'en tirer avec un grand LR (par exemple 1E-3 ou même plus). Les grands réseaux ont besoin de LR inférieurs. 3E-4 est un choix sûr dans la plupart des applications de taille moyenne, mais peut être trop faible pour les petits réseaux, alors essayez de l'augmenter! Enfin, Max_Iters est la durée de la formation. Jouez avec différents paramètres. Je ne réglent surtout ces paramètres que et je laisse la plupart des autres inchangés. Voici un exemple de la façon dont j'ai formé le modèle de 110 m, qui, je ne pense pas, est presque optimal, mais qui me semblait sensible: DIM 768, n_layers 12, n_heads 12 (donc la taille de chaque tête est 768/12 = 64 canaux), SEQ Len de 1024, Taille lot 16 (c'est le plus qui a besoin de mon A100. Les jetons de la taille du lot sont de 16 jetons de lots * 1024 jetons en séquence * 8 grad_accum = 131 072 jetons par mise à jour. Bien. Taux d'apprentissage 4E-4 (probablement un peu trop bas). Max_iters 200K (probablement un peu trop haut). Dépannage de 0,1, car cela aide généralement un peu à la taille moyenne. C'était ça. J'ai couru en utilisant des données distribuées parallèles (DDP) sur 4 GPU sur ma machine cloud, la formation a pris environ un jour.

Licence

Mit

Citation

Si vous utilisez ce code, veuillez citer notre travail:

 @misc{jain2023mechanistically,
    title={Mechanistically analyzing the effects of fine-tuning on procedurally defined tasks},
    author={Samyak Jain and Robert Kirk and Ekdeep Singh Lubana and Robert P. Dick and Hidenori Tanaka and Edward Grefenstette and Tim Rocktäschel and David Scott Krueger},
    year={2023},
    eprint={2311.12786},
    archivePrefix={arXiv},
    primaryClass={cs.LG}
}

Vous devez également citer le papier Tinystories:

 @misc{eldan2023tinystories,
    title={TinyStories: How Small Can Language Models Be and Still Speak Coherent English?},
    author={Ronen Eldan and Yuanzhi Li},
    year={2023},
    eprint={2305.07759},
    archivePrefix={arXiv},
    primaryClass={cs.CL}
}