Lion : Distillation contradictoire pour les grands modèles de langage à source fermée

En modifiant les données de trace d'instructions 70k, Lion (7B) peut atteindre 95% de la puissance de ChatGPT !

information

Nous travaillons actuellement sur la formation de versions de plus grande taille (13B, 33B et 65B si possible). Merci pour votre patience.

**[10 juin 2023]** Nous avons publié des instructions pour résoudre OOM lors du réglage fin, veuillez les vérifier pendant la formation .
**[26 mai 2023]** Nous avons publié les pondérations des modèles. Découvrez le modèle 7B !
**[25 mai 2023]** Nous avons publié une démo en ligne , essayez notre modèle ici !
**[23 mai 2023]** Nous avons publié le code pour la formation et l'inférence.

contenu

Annuaire d'articles

aperçu

Un aperçu de haut niveau de notre cadre de distillation contradictoire, où nous élaborons un LLM étudiant compact basé sur un LLM avancé à source fermée qui remplit trois rôles : enseignant **, arbitre et générateur ** . De gauche à droite, l'itération est divisée en trois phases :

La phase d'imitation*,* aligne les réponses de l'élève sur celles de l'enseignant ;
Une phase de discrimination qui identifie les échantillons durs ;
La phase de génération, utilisée pour générer de nouveaux échantillons durs*,* pour faire évoluer le challenge vers le modèle étudiant.

démo en ligne

Nous garderons les derniers modèles disponibles pour que vous puissiez les essayer aussi longtemps que possible. N'hésitez pas à poser des questions à Lion, nous serions ravis d'entendre vos commentaires !

Lien de démonstration (expire après 72 heures, nous mettrons donc à jour le lien régulièrement)

Étant donné que les données d'entraînement sont des exemples d'instructions en anglais, il est préférable de poser vos questions en anglais. Cependant, nous avons constaté que Lion peut également comprendre les commandes d'autres langues dans une certaine mesure. Considérez l'exemple suivant :

Restaurer les poids du Lion

Nous publions les poids Lion sous forme de poids incrémentiels pour se conformer à la licence du modèle LLaMA.

Lion-7B (contrepoids incrémentiel)

Vous pouvez ajouter nos deltas aux poids LLaMA d'origine pour obtenir des poids Lion. instruire:

Suivez les instructions ici pour obtenir les poids bruts LLaMA au format Huggingface
Veuillez télécharger notre modèle Delta de Hugging Face
Utilisez le script suivant pour obtenir les pondérations du Lion en appliquant nos deltas :

python src/weight_diff.py recover --path_raw huggyllama/llama-7b --path_diff YuxinJiang/Lion --path_tuned <path_to_store_recovered_weights>

raisonnement

Pour l'inférence et la formation Lion, veuillez d'abord installer la configuration requise :

pip install -r requirements.txt

Nous fournissons à Lion un script de décodage qui lit un fichier d'entrée et génère une réponse correspondante pour chaque échantillon, puis les fusionne dans un fichier de sortie. Il peut fonctionner sur une seule machine avec un GPU de 16 Go.

python src/lion_inference.py \
    --model_dir <path_to_hf_converted_lion_ckpt_and_tokenizer> \
    --data_dir <path_to_input_json_file> \
    --output_dir <path_to_output_json_file> \
    --num_gpus 1

processus de formation

Une itération de notre cadre de distillation contradictoire est illustrée ci-dessous.

1. Étape d'imitation

1.1 Obtenir la réponse de l'enseignant au Train Pool

python src/chatgpt_inference.py \
    -q <path_to_json_file_for_the_Train_Pool> \
    -o <path_to_chatgpt_inference_for_the_Train_Pool> \
    --api_key <your_openai_api_key>

1.2 Faire des ajustements d'instruction aux élèves en fonction de la réponse de l'enseignant au bassin de formation

Le réglage fin a été effectué sur une machine avec 8 GPU A100 80G.

torchrun --nproc_per_node=8 --master_port=<your_random_port> src/train.py \
    --model_name_or_path <path_to_hf_converted_ckpt_and_tokenizer> \
    --data_path <path_to_chatgpt_inference_for_the_Train_Pool> \
    --bf16 True \
    --output_dir result \
    --num_train_epochs 3 \
    --model_max_length 1024 \
    --per_device_train_batch_size 2 \
    --per_device_eval_batch_size 2 \
    --gradient_accumulation_steps 8 \
    --evaluation_strategy "no" \
    --save_strategy "steps" \
    --save_steps 500 \
    --save_total_limit 1 \
    --learning_rate 2e-5 \
    --weight_decay 0. \
    --warmup_ratio 0.03 \
    --lr_scheduler_type "cosine" \
    --logging_steps 1 \
    --fsdp "full_shard auto_wrap" \
    --fsdp_transformer_layer_cls_to_wrap 'LlamaDecoderLayer' \
    --tf32 True

Résoudre le MOO

En termes simples, environ 7 x 8 x 2 = 112 Go de VRAM sont nécessaires pour affiner le modèle 7B. Les commandes données ci-dessus activent le partitionnement des paramètres, de sorte qu'aucune copie redondante du modèle n'est stockée sur un GPU. Si vous souhaitez réduire davantage votre empreinte mémoire, voici quelques options :

Active le déchargement du processeur pour FSDP --fsdp "full_shard auto_wrap offload". Cela permet d'économiser de la VRAM au prix de durées d'exécution plus longues.

D'après notre expérience, DeepSpeed stage-3 (avec déchargement) est parfois plus économe en mémoire que FSDP avec déchargement. Voici un exemple utilisant DeepSpeed stage-3 avec 8 GPU et déchargement des paramètres et de l'optimiseur :

deepspeed src/train_deepspeed.py \
    --model_name_or_path <path_to_hf_converted_ckpt_and_tokenizer> \
    --data_path <path_to_chatgpt_inference_for_the_Train_Pool> \
    --output_dir result \
    --num_train_epochs 3 \
    --model_max_length 1024 \
    --per_device_train_batch_size 16 \
    --per_device_eval_batch_size 1 \
    --gradient_accumulation_steps 1 \
    --evaluation_strategy "no" \
    --save_strategy "steps" \
    --save_steps 600 \
    --save_total_limit 1 \
    --learning_rate 2e-5 \
    --warmup_ratio 0.03 \
    --logging_steps 1 \
    --lr_scheduler_type "cosine" \
    --report_to "tensorboard" \
    --gradient_checkpointing True \
    --deepspeed srcs/configs/deepspeed_config.json \
    --fp16 True

La bibliothèque DeepSpeed fournit également quelques fonctions utiles pour estimer l'utilisation de la mémoire.

LoRA affine les tranches de rang inférieur des en-têtes d'intégration de requête, de clé et de valeur. Cela réduit l'empreinte mémoire totale de 112 Go à environ 7x4 = 28 Go. Nous pourrions publier une réimplémentation de ceci dans le futur, mais pour l'instant la base de code peft peut être une ressource utile.

2. Stade de discrimination

2.1 Obtenir la réponse de l'enseignant au pool de cache

python src/chatgpt_inference.py \
    -q <path_to_json_file_for_the_Cache_Pool> \
    -o <path_to_chatgpt_inference_for_the_Cache_Pool> \
    --api_key <your_openai_api_key>

2.2 Obtenir les réponses des élèves au pool de cache

python src/lion_inference.py \
    --model_dir <path_to_hf_converted_lion_ckpt_and_tokenizer> \
    --data_dir <path_to_json_file_for_the_Cache_Pool> \
    --output_dir <path_to_lion_inference_for_the_Cache_Pool> \
    --num_gpus 8

2.3 Demandez à l'arbitre de produire deux notes en fonction de la qualité des réponses de l'enseignant et de l'élève

python src/chatgpt_referee.py \
    -a <path_to_chatgpt_inference_for_the_Cache_Pool> <path_to_lion_inference_for_the_Cache_Pool> \
    -o <path_to_output_review_file> \
    --api_key <your_openai_api_key>

2.4 Distinguer les commandes dures des commandes simples

python src/discrimination.py \
    --review_path <path_to_output_review_file> \
    --chatgpt_inference_path <path_to_chatgpt_inference_for_the_Cache_Pool> \
    --lion_inference_path <path_to_lion_inference_for_the_Cache_Pool> \
    --hard_save_path <path_to_identified_hard_instructions> \
    --easy_save_path <path_to_identified_easy_instructions>

3. Phase de génération

3.1 Générer de nouvelles instructions matérielles

python -m src/generate_hard_instruction generate_instruction_following_data \
    --seed_tasks_path <path_to_identified_hard_instructions> \
    --output_dir <path_to_generated_hard_instructions> \
    --num_instructions_to_generate 3000 \
    --api_key <your_openai_api_key>

3.2 Générer de nouvelles instructions simples

python -m src/generate_easy_instruction generate_instruction_following_data \
    --seed_tasks_path <path_to_identified_easy_instructions> \
    --output_dir <path_to_generated_easy_instructions> \
    --num_instructions_to_generate 3000 \
    --api_key <your_openai_api_key>

Évaluer

Évaluation automatique à l'aide de GPT-4

Nous exploitons GPT-4 pour évaluer automatiquement la qualité de réponse (scores de 1 à 10) de deux modèles sur 80 commandes Vicuna invisibles . ChatGPT a été choisi comme modèle de référence pour évaluer la compétence relative des différents LL.M. Les scores relatifs sont rapportés sous forme de pourcentage, calculé comme un rapport de la somme des scores.

Qualité de réponse globale relative :

Qualité de réponse relative pour différentes catégories de tâches :

Évaluation humaine avec critères d'alignement

Nous adoptons les critères d'alignement proposés par Askel et al. (2021), qui définissent qu'un assistant est considéré comme cohérent s'il possède les traits de serviabilité, d'honnêteté et d'innocuité (HHH). Nous effectuons une évaluation humaine sur 252 instructions orientées utilisateur . Pour estimer les taux de gain, nous comparons la fréquence des gains, des nuls et des pertes entre chaque paire de modèles ci-dessous.

citation

Si vous utilisez le code de ce référentiel, veuillez citer notre article.

@article{DBLP:journals/corr/abs-2305-12870,
  author       = {Yuxin Jiang and
                  Chunkit Chan and
                  Mingyang Chen and
                  Wei Wang},
  title        = {Lion: Adversarial Distillation of Closed-Source Large Language Model},
  journal      = {CoRR},
  volume       = {abs/2305.12870},
  year         = {2023},
  url          = {https://doi.org/10.48550/arXiv.2305.12870},
  doi          = {10.48550/arXiv.2305.12870},
  eprinttype    = {arXiv},
  eprint       = {2305.12870},
  timestamp    = {Fri, 26 May 2023 11:29:33 +0200},
  biburl       = {https://dblp.org/rec/journals/corr/abs-2305-12870.bib},
  bibsource    = {dblp computer science bibliography, https://dblp.org}
}

clause de non-responsabilité

Xiv},
eprint = {2305.12870},
timestamp = {Fri, 26 May 2023 11:29:33 +0200},
biburl = {https://dblp.org/rec/journals/corr/abs-2305-12870.bib},
bibsource = {dblp computer science bibliography, https://dblp.org}
}


## 免责声明

⚠️Lion**仅供研究使用**并获得许可。**严禁**商业用途。任何版本的Lion生成的内容都会受到随机性等不可控变量的影响，因此本项目无法保证输出的准确性。本项目对模型输出的内容不承担任何法律责任，也不承担因使用相关资源和输出结果而产生的任何损失。