InstructionModelling Descargar - Descargar el código fuente InstructionModelling

Ajuste de instrucciones con pérdida sobre instrucciones

Este repositorio proporciona el código para nuestro documento titulado Titing de instrucciones con pérdidas sobre las instrucciones , lo que hace que la integración de nuestras contribuciones de código en otros proyectos sea más accesible.

Nuestro estudio identifica aún más factores clave que influyen en la efectividad del modelado de instrucciones: (1) la relación entre la longitud de la instrucción y la longitud de salida. (Figura izquierda). (2) El número de ejemplos de capacitación. (Figura correcta).

Enlaces rápidos

Ajuste de instrucciones con pérdida sobre instrucciones
- Enlaces rápidos
- Descripción general
- 1. Requisitos e instalación
- 2. Entrenamiento
- 3. Evaluación
- 4. Análisis de reproducción
- Errores o preguntas?
- Citación
- Expresiones de gratitud

Descripción general

Puede reproducir los experimentos de nuestra instrucción en papel sintonizar con pérdidas sobre las instrucciones.

La sintonización de instrucciones abstractas juega un papel crucial en la configuración de las salidas de los modelos de lenguaje (LMS) a los estilos deseados. En este trabajo, proponemos un método simple pero efectivo, modelado de instrucciones (IM), que entrena a LMS aplicando una función de pérdida a la instrucción y la parte rápida en lugar de solo a la parte de salida. A través de experimentos en 21 puntos de referencia diversos, mostramos que, en muchos escenarios, IM puede mejorar efectivamente el rendimiento de LM tanto en las tareas de PNL (p. Ej. Sorprendentemente, en el caso más ventajoso, IM aumenta el rendimiento del modelo en Alpacaeval 1.0 en más del 100%. Identificamos dos factores clave que influyen en la efectividad de IM: (1) la relación entre la longitud de la instrucción y la longitud de salida en los datos de entrenamiento; y (2) el número de ejemplos de capacitación. Observamos que IM es especialmente beneficioso cuando se entrena en conjuntos de datos con largas instrucciones combinadas con breves salidas, o bajo la hipótesis de alineación superficial (SAH) donde se usa una pequeña cantidad de ejemplos de entrenamiento para el ajuste de instrucciones. Un análisis posterior corrobora nuestra hipótesis de que la mejora puede atribuirse a una reducción del sobreajuste a los conjuntos de datos de ajuste de instrucciones. Nuestro trabajo proporciona orientación práctica para la sintonización de instrucciones LMS, especialmente en escenarios de baja recursos.

1. Requisitos e instalación

Para instalar los paquetes requeridos para nuestros enfoques de línea de base (enfoques semi-supervisados), puede ejecutar el siguiente comando.

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

Para los datos de capacitación, hemos proporcionado los datos procesados en el directorio data para 7 conjuntos de datos de ajuste de instrucciones. Puede descargar otros datos de los siguientes enlaces:

sh prepare_train_data.sh

Además, descargamos menos datos del Princeton NLP Less Data.

Para descargar los datos para el conjunto de datos Alpagasus, puede ejecutar el siguiente comando.

sh prepare_alpagasus_data.sh

2. Entrenamiento

Aquí proporcionamos las instrucciones para capacitar a los modelos para el ajuste de instrucciones estándar, el modelado de instrucciones (nuestro) y los modelos de referencia.

Para entrenar el modelo de ajuste de instrucciones, puede ejecutar el siguiente comando.

 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

Para entrenar el modelo de modelado de instrucciones, puede ejecutar el siguiente comando. Este es nuestro método propuesto.

 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

Para entrenar a los modelos de referencia (NEFTUNE), puede ejecutar el siguiente comando.

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. Evaluación

Aquí proporcionamos las instrucciones para evaluar los modelos para el ajuste de instrucciones estándar, el modelado de instrucciones (nuestro) y los modelos de referencia. Realizamos la evaluación utilizando el repositorio de código abierto FastChat, LLM-Evaluation-Harness, Alpacaeval. Consulte los repositorios respectivos para obtener más detalles. Instale los paquetes requeridos para la evaluación.

Para evaluar el modelo en las tareas NLP tradicionales, puede ejecutar el siguiente comando.

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
)

Para evaluar el modelo en el conjunto de datos MT-Bench, puede ejecutar el siguiente comando.

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

Para evaluar el modelo en el conjunto de datos Alpacaeval, puede ejecutar el siguiente comando.

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

Aquí puede establecer el IS_ALPACA_EVAL_2 en True para evaluar el modelo en el conjunto de datos Alpacaeval-2. Si solo desea realizar la generación sin realizar la evaluación, puede usar el argumento --no_evaluate_with_llm .

4. Análisis de reproducción

Para reproducir el análisis del documento, puede ejecutar el siguiente comando.

Para calcular la pérdida de tren o prueba del modelo, puede ejecutar el siguiente comando.

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

Errores o preguntas?

Si tiene alguna pregunta sobre el código o el documento, no dude en comunicarse con los autores en [email protected] . Si experimenta alguna dificultad mientras usa el código o necesita informar un error, no dude en abrir un problema. Pedimos amablemente que proporcione información detallada sobre el problema para ayudarnos a proporcionar un soporte efectivo.

Citación

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