LLM Pruner

LLM-PRIMER: Sobre la poda estructural de modelos de idiomas grandes [ARXIV]
Xinyin MA, Gongfan Fang, Xinchao Wang
Universidad Nacional de Singapur

• Compresión agnóstica de tareas : el LLM comprimido debe conservar su capacidad original como solucionador de tareas múltiples.
• Menos Corpus de capacitación : en este trabajo, usamos solo 50k muestras disponibles públicamente (AlpACA) para posterior al entrenamiento de la LLM.
• Compresión eficiente : 3 minutos para poda y 3 horas para después del entrenamiento. (Puedes hacerlo más tiempo)
• Poda estructural automática : poda nueva LLM con un esfuerzo humano mínimo (en progreso).

• Llama-3.1
• LLAMA-3
• Llama-2
• Llama
• FLORACIÓN
• Vicuna
• Baichuan
• Tinllama

• 27 de julio de 2024: ¡Apoya GQA! Ahora LLM-PRIMER puede trabajar en LLAMA3 y LLAMA 3.1. Todavía estamos probando los resultados de la poda de New LLMS (LLAMA3, LLAMA3.1, Gemma) y puede encontrar los resultados de la poda aquí.
• 30 de agosto de 2023: ¿LLM-PRUNER ahora admite Bloom?
• 14 de agosto de 2023: ahora están disponibles el código y los resultados para la sintonización con un corpus a gran escala. El modelo de Llama-5.4B ajustado logra una precisión promedio de 62.36%, acercándose estrechamente al LLAMA-7B original (63.25%).
• 19 de julio de 2023: LLM-Pruner ahora admite Llama-2-7B y LLAMA-2-13B (la versión de Huggingface)
• 18 de julio de 2023: Apoyo a Baichuan, un LLM bilingüe.
• 20 de mayo de 2023 :? Código y papel de preimpresión lanzado!

• Un tutorial para podar nuevos LLM.
• Soporte .from_pretrained() para cargar el modelo.

Únase a nuestro grupo WeChat para charlar:

• WeChat Group Group-2 (> 200/500), Grupo-1 (500/500, completo).

• Comienzo rápido
• Instrucciones paso a paso
• Evaluación de disparo cero
• Más pruebas
• Información de la versión
• Limitaciones
• Reconocimiento
• Citación

 pip install -r requirement.txt

 bash script/llama_prune.sh

Este script comprimiría el modelo LLAMA-7B con ～ 20% de parámetros podados. Todos los modelos previamente capacitados y el conjunto de datos se descargarían automáticamente, por lo que no necesita descargar manualmente el recurso. Al ejecutar este script por primera vez, requerirá algo de tiempo para descargar el modelo y el conjunto de datos.

Se necesitan tres pasos para podar un LLM:

• Etapa de descubrimiento: descubra la complicada interdependencia en LLMS y encuentre la unidad mínimamente removible, el grupo .
• Etapa de estimación: estimar la contribución de cada grupo al rendimiento general del modelo y decidir qué grupo podar.
• Etapa de recuperación: Castrado rápido para recuperar el rendimiento del modelo.

Después de la poda y el post-entrenamiento, seguimos a la evaluación de LM-Evaluation para la evaluación.

? Llama/Llama-2 poda con ~ 20% de parámetros podados:

 python hf_prune.py --pruning_ratio 0.25 
      --block_wise 
      --block_mlp_layer_start 4 --block_mlp_layer_end 30 
      --block_attention_layer_start 4 --block_attention_layer_end 30 
      --pruner_type taylor 
      --test_after_train 
      --device cpu  --eval_device cuda 
      --save_ckpt_log_name llama_prune 

Argumentos:

• Base model : elija el modelo base de Llama o LLAMA-2 y pase el pretrained_model_name_or_path a --base_model . El nombre del modelo se utiliza para AutoModel.from_pretrained . Por ejemplo, si desea usar el LLAMA-2 con 13 mil millones de parámetros, luego pase meta-llama/Llama-2-13b-hf a-- --base_model .
• Pruning Strategy : elija entre la poda de bloqueo, canal o en cuanto a la capa utilizando las opciones de comando respectivas: {--BLOCK_WISE}, {--channel_wise}, {-layer_wise -layer number_of_layers}. Para la poda de bloques, especifique las capas de inicio y finalización para ser podadas. La poda de canal no requiere argumentos adicionales. Para la poda de capas, use --layer number_of_layers para especificar el número deseado de capas que se mantendrán después de la poda.
• Importance Criterion : Seleccione de L1, L2, Random o Taylor usando el argumento --pruner_type. Para Taylor Pruner, elija una de las siguientes opciones: Vectorize, Param_Second, Param_First, Param_Mix. Por defecto, se usa Param_Mix, que combina gradiente de hessian y de primer orden aproximado. Si usa L1, L2 o aleatorio, no se requieren argumentos adicionales.
• Pruning Ratio : especifica la relación de poda de grupos. Se diferencia de la velocidad de poda de los parámetros, ya que los grupos se eliminan como las unidades mínimas.
• Device y Eval_device : la poda y la evaluación se pueden realizar en diferentes dispositivos. Los métodos basados ​​en Taylor requieren un cálculo hacia atrás durante la poda, lo que puede requerir una RAM significativa de GPU. Nuestra implementación utiliza la CPU para la estimación de importancia (también admite GPU, simplemente use --Device CUDA). Eval_device se usa para probar el modelo podado.

 python hf_prune.py --pruning_ratio 0.25 
      --block_wise 
      --block_mlp_layer_start 4 --block_mlp_layer_end 30 
      --block_attention_layer_start 4 --block_attention_layer_end 30 
      --pruner_type taylor 
      --test_after_train 
      --device cpu  --eval_device cuda 
      --save_ckpt_log_name llama_prune 
      --base_model PATH_TO_VICUNA_WEIGHTS

 python llama3.py --pruning_ratio 0.25 
                 --device cuda --eval_device cuda 
                 --base_model meta-llama/Meta-Llama-3-8B-Instruct 
                 --block_wise --block_mlp_layer_start 4 --block_mlp_layer_end 30 
                 --block_attention_layer_start 4 --block_attention_layer_end 30 
                 --save_ckpt_log_name llama3_prune 
                 --pruner_type taylor --taylor param_first 
                 --max_seq_len 2048 
                 --test_after_train --test_before_train --save_model 

• Entrena con alpaca con 50,000 muestras. Aquí hay un ejemplo de entrenamiento en una sola GPU:

 CUDA_VISIBLE_DEVICES=X python post_training.py --prune_model prune_log/PATH_TO_PRUNE_MODEL/pytorch_model.bin 
      --data_path yahma/alpaca-cleaned 
      --lora_r 8 
      --num_epochs 2  
      --learning_rate 1e-4  
      --batch_size 64 
      --output_dir tune_log/PATH_TO_SAVE_TUNE_MODEL  
      --wandb_project llama_tune

Asegúrese de reemplazar PATH_TO_PRUNE_MODEL con la ruta al modelo podado en el paso 1 y reemplazar PATH_TO_SAVE_TUNE_MODEL con la ubicación deseada donde desea guardar el modelo sintonizado.

Consejo : el entrenamiento Llama-2 en Float16 no se recomienda y se sabe que produce Nan; Como tal, el modelo debe ser entrenado en BFLOAT16.

• Entrena usando insincrencia Mbzuai/Lamini con muestras de 2,59 m. Aquí hay un ejemplo que usa múltiples GPU para el entrenamiento:

 deepspeed --include=localhost:1,2,3,4 post_training.py 
      --prune_model prune_log/PATH_TO_PRUNE_MODEL/pytorch_model.bin 
      --data_path MBZUAI/LaMini-instruction  
      --lora_r 8 
      --num_epochs 3  
      --output_dir tune_log/PATH_TO_SAVE_TUNE_MODEL 
      --extra_val_dataset wikitext2,ptb 
      --wandb_project llmpruner_lamini_tune 
      --learning_rate 5e-5 
      --cache_dataset

Para el modelo podado, simplemente use el siguiente comando para cargar su modelo.

  pruned_dict = torch.load(YOUR_CHECKPOINT_PATH, map_location='cpu')
  tokenizer, model = pruned_dict['tokenizer'], pruned_dict['model']

Debido a las diferentes configuraciones entre los módulos en el modelo podado, donde ciertas capas pueden tener un ancho más grande, mientras que otras han sufrido más poda, no se vuelve práctico cargar el modelo utilizando el .from_pretrained() según lo dispuesto por la cara abrazada. Actualmente, empleamos la torch.save para almacenar el modelo podado.

Dado que el modelo podado tiene una configuración diferente en cada capa, como algunas capas pueden ser más anchas, pero algunas capas se han podado más, el modelo no se puede cargar con el .from_pretrained() en la cara abrazada. Actualmente, simplemente usamos el torch.save para guardar el modelo podado y la torch.load .

Proporcionamos un script simple para generar textos utilizando modelos previamente capacitados / podados / modelos podados con post-entrenamiento.

• LLAMA-7B previamente entrenado

 python generate.py --model_type pretrain

• Modelo podado sin post-entrenamiento

 python generate.py --model_type pruneLLM --ckpt <YOUR_MODEL_PATH_FOR_PRUNE_MODEL>

• Modelo podado con post-entrenamiento

 python generate.py --model_type tune_prune_LLM --ckpt <YOUR_CKPT_PATH_FOR_PRUNE_MODEL> --lora_ckpt <YOUR_CKPT_PATH_FOR_LORA_WEIGHT>

Las instrucciones anteriores implementarán sus LLM localmente.

Para evaluar el desempeño del modelo podado, seguimos la sede de evaluación LM para evaluar el modelo:

• Paso 1: Si solo necesita evaluar el modelo podado, omita este paso y salte al paso 2. Este paso es organizar los archivos para satisfacer el requisito de entrada para lm-evaluation-harness . El punto de control sintonizado desde el paso posterior a la capacitación se guardaría en el siguiente formato:

 - PATH_TO_SAVE_TUNE_MODEL
  | - checkpoint-200
      | - pytorch_model.bin
      | - optimizer.pt
      ...
  | - checkpoint-400
  | - checkpoint-600
  ...
  | - adapter_config.bin
  | - adapter-config.json

Organice los archivos mediante los siguientes comandos:

 cd PATH_TO_SAVE_TUNE_MODEL
export epoch=YOUR_EVALUATE_EPOCH
cp adapter_config.json checkpoint-$epoch/
mv checkpoint-$epoch/pytorch_model.bin checkpoint-$epoch/adapter_model.bin

Si desea evaluar el checkpoint-200 , establezca la época igual a 200 por export epoch=200 .

• Paso 2:

 export PYTHONPATH='.'
python lm-evaluation-harness/main.py --model hf-causal-experimental 
       --model_args checkpoint=PATH_TO_PRUNE_MODEL,peft=PATH_TO_SAVE_TUNE_MODEL,config_pretrained=PATH_OR_NAME_TO_BASE_MODEL 
       --tasks openbookqa,arc_easy,winogrande,hellaswag,arc_challenge,piqa,boolq 
       --device cuda:0 --no_cache 
       --output_path PATH_TO_SAVE_EVALUATION_LOG 

Aquí, reemplace PATH_TO_PRUNE_MODEL y PATH_TO_SAVE_TUNE_MODEL con la ruta que guarde el modelo podado y el modelo sintonizado, y PATH_OR_NAME_TO_BASE_MODEL es para cargar el archivo de configuración del modelo base.

[Actualización]: Cargamos un script para simplemente el proceso de evaluación si desea evaluar el modelo podado con el punto de control sintonizado. Simplemente use el siguiente comando:

 CUDA_VISIBLE_DEVICES=X bash scripts/evaluate.sh PATH_OR_NAME_TO_BASE_MODEL PATH_TO_SAVE_TUNE_MODEL  PATH_TO_PRUNE_MODEL EPOCHS_YOU_WANT_TO_EVALUATE

Reemplace la información necesaria de su modelo en el comando. El último se usa para iterar sobre diferentes épocas si desea evaluar varios puntos de control en un comando. Por ejemplo:

 CUDA_VISIBLE_DEVICES=1 bash scripts/evaluate.sh decapoda-research/llama-7b-hf tune_log/llama_7B_hessian prune_log/llama_prune_7B 200 1000 2000

• Pre-entrenado

 python test_speedup.py --model_type pretrain

• Modelo podado

 python test_speedup.py --model_type pruneLLM --ckpt <YOUR_MODEL_PATH_FOR_PRUNE_MODEL>

Un breve resultados cuantitativos para Llama-7B:

Los resultados para Vicuna-7b:

Los resultados para chatglm-6b:

Estadísticas para modelos podados:

Resultados de LLM-liber con muestras de 2.59m:

Se pueden encontrar más resultados en el documento.

Debido a los cambios en las versiones de los modelos y los repositorios utilizados en este proyecto, enumeramos algunos problemas de versión conocidos y las versiones específicas necesarias para reproducir nuestro método:

1. LM-Eval-Harness: utilizamos este compromiso de LM-Evaluation-Harness, y el código también se incluye en este repositorio. Consulte el problema #25 para más detalles.
2. LLAMA1-7B: Utilizamos el punto de control de Decapoda-Research/Llama-7B-HF en nuestros experimentos, que no está disponible ahora. Considere usar la versión copiada, por ejemplo, Baffo32/Decapoda-Research-Llama-7B-HF.

• Aunque solo usamos datos de 50k y entrenamos durante tres horas, más datos definitivamente serían mejores. Estamos probando en esto.
• El modelo comprimido actual todavía tiene varios problemas, como generar tokens repetitivos o producir oraciones sin sentido. Creemos que hay un margen significativo para la mejora en la calidad del modelo comprimido.
• Todavía hay algunos modelos para los que no podemos identificar automáticamente la asignación de índices después de la concatenación y las operaciones de vista. Por lo tanto, necesitamos realizar operaciones manuales adicionales.

• El logotipo se genera por difusión estable
• La evaluación de la LLM: LM-Evaluation-Harness
• Llama: https://github.com/facebookresearch/llama
• Vicuna: https://github.com/lm-sys/fastchat
• Peft: https://github.com/huggingface/peft
• Alpaca-Lora: https://github.com/tloen/alpaca-lora

Si encuentra útil este proyecto, cite

 @inproceedings{ma2023llmpruner,
  title={LLM-Pruner: On the Structural Pruning of Large Language Models},
  author={Xinyin Ma and Gongfan Fang and Xinchao Wang},
  booktitle={Advances in Neural Information Processing Systems},
  year={2023},
}

 @article{fang2023depgraph,
  title={DepGraph: Towards Any Structural Pruning},
  author={Fang, Gongfan and Ma, Xinyin and Song, Mingli and Mi, Michael Bi and Wang, Xinchao},
  journal={The IEEE/CVF Conference on Computer Vision and Pattern Recognition},
  year={2023}
}