InstructionModelling herunterladen - InstructionModelling -Quellcode Download

Anweisungsstimmung mit Verlust über Anweisungen

Dieses Repository enthält den Code für unser Papier mit dem Titel "Anweisungen" mit Verlust über Anweisungen , wodurch die Integration unserer Codebeiträge in andere Projekte zugänglicher wird.

Unsere Studie identifiziert weiterhin Schlüsselfaktoren, die die Wirksamkeit der Anweisungsmodellierung beeinflussen: (1) das Verhältnis zwischen Anweisungslänge und Ausgangslänge. (Linke Abbildung). (2) Die Anzahl der Trainingsbeispiele. (Rechte Abbildung).

Schnelle Links

Anweisungsstimmung mit Verlust über Anweisungen
- Schnelle Links
- Überblick
- 1. Anforderungen und Installation
- 2. Training
- 3.. Bewertung
- 4. Reproduzierungsanalyse
- Fehler oder Fragen?
- Zitat
- Anerkennung

Überblick

Sie können die Experimente unserer Papierunterrichtsabstimmung mit Verlust über Anweisungen reproduzieren.

Die abstrakte Anweisungsabstimmung spielt eine entscheidende Rolle bei der Gestaltung der Ausgänge von Sprachmodellen (LMS) zu gewünschten Stilen. In dieser Arbeit schlagen wir eine einfache und dennoch effektive Methode vor, die Anweisungsmodellierung (IM), die LMS ausbildet, indem wir eine Verlustfunktion auf den Anweisungen und einen schnellen Teil und nicht nur auf den Ausgangsteil anwenden. Durch Experimente in 21 verschiedenen Benchmarks zeigen wir, dass IM in vielen Szenarien die LM-Leistung sowohl bei NLP-Aufgaben (z. B. MMLU, Truthfulqa und Humaneal) als auch bei der offenen Generation (z. Bemerkenswerterweise steigert IM im vorteilhaftesten Fall die Modellleistung auf Alpacaeval 1,0 um über 100%. Wir identifizieren zwei Schlüsselfaktoren, die die Wirksamkeit von IM beeinflussen: (1) das Verhältnis zwischen Anweisungslänge und Ausgangslänge in den Trainingsdaten; und (2) die Anzahl der Trainingsbeispiele. Wir stellen fest, dass IM besonders vorteilhaft ist, wenn es auf Datensätzen mit langwierigen Anweisungen mit kurzen Ausgängen oder unter der oberflächlichen Ausrichtungshypothese (SAH) trainiert wird, bei der eine kleine Anzahl von Trainingsbeispielen für die Anweisungsabstimmung verwendet wird. Weitere Analysen untergraben unsere Hypothese, dass die Verbesserung auf eine verringerte Überanpassung auf Datensätze für Anweisungen zurückzuführen ist. Unsere Arbeit bietet praktische Anleitungen für das Anweisungsabstimmen von LMS, insbesondere in Szenarien mit niedrigem Ressourcen.

1. Anforderungen und Installation

So installieren Sie die erforderlichen Pakete für unsere Basisansätze (halbübergreifende Ansätze), Sie können den folgenden Befehl ausführen.

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

Für die Schulungsdaten haben wir die verarbeiteten Daten im data für 7 Anweisungs -Tuning -Datensätze bereitgestellt. Sie können andere Daten von den folgenden Links herunterladen:

sh prepare_train_data.sh

Darüber hinaus laden wir die weniger Daten aus dem Princeton NLP weniger Daten herunter.

Um die Daten für den Alpagasus -Datensatz herunterzuladen, können Sie den folgenden Befehl ausführen.

sh prepare_alpagasus_data.sh

2. Training

Hier geben wir die Anweisungen für die Schulung der Modelle für die Standardanweisungsabstimmung, die Anweisungsmodellierung (unsere) und die Basismodelle.

Um das Anweisungsmodell zu trainieren, können Sie den folgenden Befehl ausführen.

 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

Um das Modellierungsmodell für Anweisungen zu trainieren, können Sie den folgenden Befehl ausführen. Dies ist unsere vorgeschlagene Methode.

 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

Um die Basismodelle (Neftune) zu trainieren, können Sie den folgenden Befehl ausführen.

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.. Bewertung

Hier geben wir die Anweisungen zur Bewertung der Modelle für die Standardanweisungsabstimmung, die Anweisungsmodellierung (unsere) und die Basismodelle. Wir führen die Bewertung unter Verwendung des Open-Source-Repository Fastchat, LLM-Evaluation-HARDES, Alpacaeval durch. Weitere Informationen finden Sie in den jeweiligen Repositories. Bitte installieren Sie die erforderlichen Pakete für die Bewertung.

Um das Modell bei herkömmlichen NLP -Aufgaben zu bewerten, können Sie den folgenden Befehl ausführen.

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
)

Um das Modell im MT-Bench-Datensatz zu bewerten, können Sie den folgenden Befehl ausführen.

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 ../../../

Um das Modell auf dem AlpaCaeval -Datensatz zu bewerten, können Sie den folgenden Befehl ausführen.

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

Hier können Sie die IS_ALPACA_EVAL_2 True einstellen, dass das Modell auf dem Datensatz von AlpaCaeval-2 bewertet wird. Wenn Sie nur die Generation ausführen möchten, ohne die Bewertung durchzuführen, können Sie das Argument verwenden --no_evaluate_with_llm .

4. Reproduzierungsanalyse

Um die Analyse des Papiers zu reproduzieren, können Sie den folgenden Befehl ausführen.

Um den Zug oder den Testverlust des Modells zu berechnen, können Sie den folgenden Befehl ausführen.

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

Fehler oder Fragen?

Wenn Sie Fragen zu dem Code oder dem Papier haben, können Sie sich gerne an Autoren unter [email protected] wenden. Wenn Sie Schwierigkeiten haben, wenn Sie den Code verwenden oder einen Fehler melden müssen, können Sie ein Problem öffnen. Wir bitten Sie freundlich, dass Sie detaillierte Informationen über das Problem bereitstellen, damit wir effektive Unterstützung bieten.

Zitat

 @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},
}