InstructionModelling Download - InstructionModelling Code Source Download

Réglage des instructions avec perte sur les instructions

Ce référentiel fournit le code de notre article intitulé Instruction Tuning with Loss Over Instructions , ce qui rend l'intégration de nos contributions de code dans d'autres projets plus accessibles.

Notre étude identifie en outre les facteurs clés influençant l'efficacité de la modélisation de l'instruction: (1) le rapport entre la longueur de l'instruction et la longueur de sortie. (Figure de gauche). (2) le nombre d'exemples de formation. (Figure droite).

Liens rapides

Réglage des instructions avec perte sur les instructions
- Liens rapides
- Aperçu
- 1. Exigences et installation
- 2. Formation
- 3. Évaluation
- 4. Analyse de reproduction
- Bogues ou questions?
- Citation
- Remerciements

Aperçu

Vous pouvez reproduire les expériences de notre réglage d'instructions en papier avec la perte sur les instructions.

Le réglage des instructions abstrait joue un rôle crucial dans la formation des sorties des modèles de langage (LMS) aux styles souhaités. Dans ce travail, nous proposons une méthode simple mais efficace, la modélisation des instructions (IM), qui forme LMS en appliquant une fonction de perte à la pièce d'instructions et de l'invite plutôt que uniquement à la pièce de sortie. Grâce à des expériences à travers 21 références diverses, nous montrons que, dans de nombreux scénarios, IM peut améliorer efficacement les performances LM sur les tâches NLP (par exemple, MMLU, Véri Véritude et Humaneval) et les références de génération ouverte (par exemple, MT-Banc et Alpacaeval). Remarquablement, dans le cas le plus avantageux, IM augmente les performances du modèle sur Alpacaeval 1,0 de plus de 100%. Nous identifions deux facteurs clés influençant l'efficacité de l'IM: (1) le rapport entre la longueur de l'instruction et la longueur de sortie dans les données d'entraînement; et (2) le nombre d'exemples de formation. Nous observons que la DI est particulièrement bénéfique lorsqu'elle est formée sur des ensembles de données avec de longues instructions associées à de brèves sorties, ou sous l'hypothèse d'alignement superficielle (SAH) où une petite quantité d'exemples de formation est utilisée pour le réglage des instructions. Une analyse plus approfondie étaye notre hypothèse selon laquelle l'amélioration peut être attribuée à une réduction des ensembles de données de réglage des instructions. Notre travail fournit des conseils pratiques pour le réglage des instructions LMS, en particulier dans les scénarios à faible ressource.

1. Exigences et installation

Pour installer les packages requis pour nos approches de référence (approches semi-supervisées), vous pouvez exécuter la commande suivante.

conda create -n sft python=3.10
conda activate sft
pip install -r requirements.txt

Pour les données de formation, nous avons fourni les données traitées dans le répertoire data pour 7 ensembles de données de réglage des instructions. Vous pouvez télécharger d'autres données à partir des liens suivants:

sh prepare_train_data.sh

De plus, nous téléchargeons les données moins que les données de Princeton NLP moins.

Pour télécharger les données de l'ensemble de données Alpagasus, vous pouvez exécuter la commande suivante.

sh prepare_alpagasus_data.sh

2. Formation

Ici, nous fournissons les instructions pour la formation des modèles pour le réglage des instructions standard, la modélisation des instructions (le nôtre) et les modèles de référence.

Pour former le modèle de réglage des instructions, vous pouvez exécuter la commande suivante.

 export CUDA_VISIBLE_DEVICES=0,1
MODEL_SIZE=7b
NUM_GPUS=2
BATCH_SIZE_PER_GPU=1
TOTAL_BATCH_SIZE=128
EPOCH=2
MAX_LENGTH=2048 
GRADIENT_ACC_STEPS= $(( $TOTAL_BATCH_SIZE / $NUM_GPUS / $BATCH_SIZE_PER_GPU ))
echo " Training llama model ${MODEL_SIZE} using $NUM_GPUS GPUs, $BATCH_SIZE_PER_GPU batch size per GPU, $GRADIENT_ACC_STEPS gradient accumulation steps "

DATA_NAME_LIST=(
    lima_data 
    alpagasus_3k_dolly 
    alpagasus_9k_dolly 
    alpagasus_claude_t45_alpaca 
    tydiqa 
    mmlu_chat 
    bbh_icl 
)
DATASET_PATH_LIST=(
    lima_data 
    alpagasus_3k_dolly 
    alpagasus_9k_dolly 
    alpagasus_claude_t45_alpaca 
    tydiqa_adam_sim_trainp0.05_seed3_p0.05 
    mmlu-chat_adam_sim_trainp0.05_seed3_p0.05 
    bbh-icl_adam_sim_trainp0.05_seed3_p0.05 
)
for i in " ${ ! DATA_NAME_LIST[@]} " ; do
    DATA_NAME= ${DATA_NAME_LIST[i]}
    DATASET_PATH= ${DATASET_PATH_LIST[i]}
    for LR in 2e-5 ; do
        DATA_PATH=data/ ${DATASET_PATH} .jsonl
        OUTPUT_DIR=model/ ${DATA_NAME} _llama2_ ${MODEL_SIZE} _bs ${TOTAL_BATCH_SIZE} _lr ${LR} _ml ${MAX_LENGTH} _ep ${EPOCH} _bf16
        printf ' %qn%qn%qn%qn ' " $DATA_NAME " " $DATASET_PATH " " $DATA_PATH " " $OUTPUT_DIR "

        accelerate launch 
            --mixed_precision bf16 
            --num_machines 1 
            --num_processes $NUM_GPUS 
            --use_deepspeed 
            --main_process_port 29521 
            --deepspeed_config_file ds_configs/stage3_no_offloading_accelerate.conf 
            src/finetune.py 
            --model_name_or_path meta-llama/Llama-2- ${MODEL_SIZE} -hf 
            --use_flash_attn 
            --tokenizer_name meta-llama/Llama-2- ${MODEL_SIZE} -hf 
            --use_slow_tokenizer 
            --train_file ${DATA_PATH} 
            --max_seq_length ${MAX_LENGTH} 
            --preprocessing_num_workers 16 
            --per_device_train_batch_size $BATCH_SIZE_PER_GPU 
            --gradient_accumulation_steps $GRADIENT_ACC_STEPS 
            --learning_rate ${LR} 
            --lr_scheduler_type linear 
            --warmup_ratio 0.03 
            --weight_decay 0. 
            --checkpointing_steps epoch 
            --num_train_epochs ${EPOCH} 
            --output_dir ${OUTPUT_DIR} 
            --with_tracking 
            --report_to tensorboard 
            --logging_steps 1 ;
    done ;
done

Pour former le modèle de modélisation des instructions, vous pouvez exécuter la commande suivante. Ceci est notre méthode proposée.

 for i in " ${ ! DATA_NAME_LIST[@]} " ; do
    DATA_NAME= ${DATA_NAME_LIST[i]}
    DATASET_PATH= ${DATASET_PATH_LIST[i]}
    for LR in 2e-5 ; do
        DATA_PATH=data/ ${DATASET_PATH} .jsonl
        OUTPUT_DIR=model/ ${DATA_NAME} _llama2_ ${MODEL_SIZE} _bs ${TOTAL_BATCH_SIZE} _lr ${LR} _ml ${MAX_LENGTH} _ep ${EPOCH} _bf16_im
        printf ' %qn%qn%qn%qn ' " $DATA_NAME " " $DATASET_PATH " " $DATA_PATH " " $OUTPUT_DIR "

        accelerate launch 
            --mixed_precision bf16 
            --num_machines 1 
            --num_processes $NUM_GPUS 
            --use_deepspeed 
            --deepspeed_config_file ds_configs/stage3_no_offloading_accelerate.conf 
            src/finetune.py 
            --model_name_or_path meta-llama/Llama-2- ${MODEL_SIZE} -hf 
            --use_flash_attn 
            --tokenizer_name meta-llama/Llama-2- ${MODEL_SIZE} -hf 
            --use_slow_tokenizer 
            --train_file ${DATA_PATH} 
            --max_seq_length ${MAX_LENGTH} 
            --preprocessing_num_workers 16 
            --per_device_train_batch_size $BATCH_SIZE_PER_GPU 
            --gradient_accumulation_steps $GRADIENT_ACC_STEPS 
            --learning_rate ${LR} 
            --lr_scheduler_type linear 
            --warmup_ratio 0.03 
            --weight_decay 0. 
            --checkpointing_steps epoch 
            --num_train_epochs ${EPOCH} 
            --output_dir ${OUTPUT_DIR} 
            --with_tracking 
            --report_to tensorboard 
            --logging_steps 1 
            --use_lm_loss ;
    done ;
done

Pour former les modèles de base (Neftune), vous pouvez exécuter la commande suivante.

NEFTUNE_ALPHA=5

for i in " ${ ! DATA_NAME_LIST[@]} " ; do
    DATA_NAME= ${DATA_NAME_LIST[i]}
    DATASET_PATH= ${DATASET_PATH_LIST[i]}
    for LR in 2e-5 ; do
        DATA_PATH=data/ ${DATASET_PATH} .jsonl
        OUTPUT_DIR=model/ ${DATA_NAME} _llama2_ ${MODEL_SIZE} _bs ${TOTAL_BATCH_SIZE} _lr ${LR} _ml ${MAX_LENGTH} _ep ${EPOCH} _bf16_alpha ${NEFTUNE_ALPHA}
        printf ' %qn%qn%qn%qn ' " $DATA_NAME " " $DATASET_PATH " " $DATA_PATH " " $OUTPUT_DIR "

        accelerate launch 
            --mixed_precision bf16 
            --num_machines 1 
            --num_processes $NUM_GPUS 
            --use_deepspeed 
            --deepspeed_config_file ds_configs/stage3_no_offloading_accelerate.conf 
            src/finetune.py 
            --model_name_or_path meta-llama/Llama-2- ${MODEL_SIZE} -hf 
            --use_flash_attn 
            --tokenizer_name meta-llama/Llama-2- ${MODEL_SIZE} -hf 
            --use_slow_tokenizer 
            --train_file ${DATA_PATH} 
            --max_seq_length ${MAX_LENGTH} 
            --preprocessing_num_workers 16 
            --per_device_train_batch_size $BATCH_SIZE_PER_GPU 
            --gradient_accumulation_steps $GRADIENT_ACC_STEPS 
            --learning_rate ${LR} 
            --lr_scheduler_type linear 
            --warmup_ratio 0.03 
            --weight_decay 0. 
            --checkpointing_steps epoch 
            --num_train_epochs ${EPOCH} 
            --output_dir ${OUTPUT_DIR} 
            --with_tracking 
            --report_to tensorboard 
            --logging_steps 1 
            --neftune_alpha ${NEFTUNE_ALPHA} ;
    done ;
done

3. Évaluation

Ici, nous fournissons les instructions pour évaluer les modèles pour le réglage des instructions standard, la modélisation des instructions (le nôtre) et les modèles de base. Nous effectuons l'évaluation en utilisant le référentiel open-source FastChat, l'évaluation LLM, l'alpacaeval. Veuillez vous référer aux référentiels respectifs pour plus de détails. Veuillez installer les packages requis pour l'évaluation.

Pour évaluer le modèle sur les tâches NLP traditionnelles, vous pouvez exécuter la commande suivante.

CUDA_VISIBLE_DEVICES=0,1 
MODELS_0=(
    mmlu_chat_llama2_13b_bs128_lr2e-5_ml1024_ep2_bf16_im
)
(
    for model in ${MODELS_0} ; do
        echo " Evaluating $model "
        MODEL_PATH= ${BASE_PATH} /model/ ${model}
        echo ${MODEL_PATH}

        accelerate launch --mixed_precision bf16 --multi_gpu -m lm_eval --model hf 
            --model_args pretrained= ${MODEL_PATH} ,max_length= ${MAX_LENGTH} 
            --tasks sft_eval 
            --batch_size auto 
            --write_out 
            --show_config 
            --output_path output/ ${model} 
            --log_samples

        # CODEX: Evaluating using temperature 0.1 to get the pass@1 score
        python -m eval.codex_humaneval.run_eval 
            --data_file ${BASE_PATH} /data/eval/codex_humaneval/HumanEval.jsonl.gz 
            --eval_pass_at_ks 1 
            --unbiased_sampling_size_n 20 
            --temperature 0.1 
            --save_dir results_humaneval/ ${model} _t01 
            --model ${MODEL_PATH} 
            --tokenizer ${MODEL_PATH} 
            --use_vllm

        # CODEX: Evaluating using temperature 0.8 to get the pass@10 score
        python -m eval.codex_humaneval.run_eval 
            --data_file ${BASE_PATH} /data/eval/codex_humaneval/HumanEval.jsonl.gz 
            --eval_pass_at_ks 1 
            --unbiased_sampling_size_n 20 
            --temperature 0.7 
            --save_dir results_humaneval/ ${model} _t07 
            --model ${MODEL_PATH} 
            --tokenizer ${MODEL_PATH} 
            --use_vllm ;
    done
)

Pour évaluer le modèle sur l'ensemble de données MT-Bench, vous pouvez exécuter la commande suivante.

MODELS=mmlu_chat_llama2_13b_bs128_lr2e-5_ml1024_ep2_bf16_im
cd FastChat/fastchat/llm_judge

for model in $MODELS ; do
    echo " Evaluating $model "

    echo " Firstly, Generate model answers to MT-bench questions "
    python gen_model_answer.py --model-path ${MODEL_PATH} / ${model} --model-id ${model}

    echo " ≈, Evaluate model answers using OpenAI API "
    python gen_judgment.py --model-list ${model} --parallel 2 ;
done

# To show the results
cd FastChat/fastchat/llm_judge
python show_result.py
python show_result.py --model-list model_name1 model_name2 # to show the results of the specified models
cd ../../../

Pour évaluer le modèle sur l'ensemble de données alpacaeval, vous pouvez exécuter la commande suivante.

MODELS=mmlu_chat_llama2_13b_bs128_lr2e-5_ml1024_ep2_bf16_im
export IS_ALPACA_EVAL_2=False
for model in $MODELS ; do
    CUDA_VISIBLE_DEVICES=0 python -m eval.alpaca_farm.run_eval 
        --model_name_or_path  ${BASE_PATH} / ${model} 
        --save_dir results_alpaca_eval/ ${model} 
        --eval_batch_size 20 
        --use_vllm 
        --use_chat_format 
        --chat_formatting_function eval.templates.create_prompt_with_tulu_chat_format ;
done

Ici, vous pouvez définir l' IS_ALPACA_EVAL_2 sur True pour évaluer le modèle sur l'ensemble de données Alpacaeval-2. Si vous souhaitez simplement effectuer la génération sans effectuer l'évaluation, vous pouvez utiliser l'argument --no_evaluate_with_llm .

4. Analyse de reproduction

Pour reproduire l'analyse du papier, vous pouvez exécuter la commande suivante.

Pour calculer le train ou tester la perte du modèle, vous pouvez exécuter la commande suivante.

MODEL_NMAES= " lima_data_llama2_7b_bs128_lr2e-5_ml2048_ep2_bf16 "
DATA_NAME_LIST=(
    lima_data 
    tulu_dataset_01 
)
DATASET_PATH_LIST=(
    lima_data 
    tulu_dataset_01 
)
for i in " ${ ! DATA_NAME_LIST[@]} " ; do
    DATA_NAME= ${DATA_NAME_LIST[i]}
    DATASET_PATH= ${DATASET_PATH_LIST[i]}
    DATA_PATH=data/ ${DATASET_PATH} .jsonl
    for model in $MODEL_NMAES ; do
        accelerate launch 
            --main_process_port 29399 
            --mixed_precision bf16 
            --num_machines 1 
            --num_processes $NUM_GPUS 
            --use_deepspeed 
            --deepspeed_config_file ds_configs/stage3_no_offloading_accelerate.conf 
            open_instruct/compute_loss.py 
            --model_name_or_path ${BASE_PATH} / ${model} 
            --use_flash_attn 
            --tokenizer_name ${BASE_PATH} / ${model} 
            --use_slow_tokenizer 
            --eval_file ${DATA_PATH} 
            --max_seq_length ${MAX_LENGTH} 
            --preprocessing_num_workers 16 
            --per_device_eval_batch_size $BATCH_SIZE_PER_GPU 
            --output_dir output_loss/ ${model} _ ${DATA_NAME} ;
    done ;
done

Bogues ou questions?

Si vous avez des questions concernant le code ou le document, n'hésitez pas à contacter les auteurs à [email protected] . Si vous rencontrez des difficultés tout en utilisant le code ou devez signaler un bogue, n'hésitez pas à ouvrir un problème. Nous vous demandons de fournir des informations détaillées sur le problème pour nous aider à fournir un soutien efficace.

Citation

 @article{shi2024instruction,
title={Instruction Tuning With Loss Over Instructions},
author={Zhengyan Shi and Adam X. Yang and Bin Wu and Laurence Aitchison and Emine Yilmaz and Aldo Lipani},
booktitle={ArXiv},
year={2024},
url={https://arxiv.org/abs/2405.14394},
}