Introducción y puesta a punto de Baichuan-13B

Enterprise 2023-07-29 12:59:26 views: null

Directorio de artículos

Introducción de Baichuan-13B

¡El 11 de julio de 2023, Baichuan Intelligent lanzó Baichuan-13B!
dirección de github: https://github.com/baichuan-inc/Baichuan-13B

Características de Baichuan-13B

Baichuan-13B es un modelo de idioma a gran escala de código abierto y disponible comercialmente que contiene 13 000 millones de parámetros desarrollados por Baichuan Intelligent después de Baichuan-7B. Ha logrado los mejores resultados del mismo tamaño en los puntos de referencia autorizados en chino e inglés. Esta versión contiene dos versiones de preentrenamiento (Baichuan-13B-Base) y alineación (Baichuan-13B-Chat) . Baichuan-13B tiene las siguientes características:

  • Tamaño más grande, más datos : Baichuan-13B amplía aún más la cantidad de parámetros a 13 mil millones sobre la base de Baichuan-7B, y entrena 1,4 billones de tokens en un corpus de alta calidad , que es un 40 % más que LLaMA-13B. código abierto El modelo con la mayor cantidad de datos de entrenamiento en el tamaño 13B. Admite bilingüe chino e inglés, usa el código de posición ALiBi , la longitud de la ventana de contexto es 4096 .
  • Al mismo tiempo, modelos de preentrenamiento y alineación de código abierto : el modelo de preentrenamiento es la "base" para los desarrolladores, y la mayoría de los usuarios comunes tienen mayores demandas de modelos de alineación con funciones de diálogo. Por lo tanto, este código abierto también lanzamos el modelo de alineación (Baichuan-13B-Chat), que tiene una fuerte capacidad de diálogo, está listo para usar y se puede implementar fácilmente con unas pocas líneas de código.
  • Razonamiento más eficiente : para admitir el uso de más usuarios, hemos abierto las versiones cuantificadas de int8 e int4 al mismo tiempo. En comparación con la versión no cuantificada, reduce en gran medida el umbral de recursos de la máquina para la implementación con casi no hay pérdida de efecto y se puede implementar en una tarjeta gráfica de consumo como la Nvidia 3090.
  • Código abierto, gratuito y disponible comercialmente : Baichuan-13B no solo está completamente abierto a la investigación académica, los desarrolladores también pueden usarlo para uso comercial gratuito solo después de presentar una solicitud por correo electrónico y obtener una licencia comercial oficial.

Efecto Baichuan-13B

¡ Baichuan-13B ocupa el puesto 10 en C-Eval !
inserte la descripción de la imagen aquí
El rendimiento del modelo Baichuan-13B en la lista CMMLU bajo cinco disparos y cero disparos es el siguiente:
Cinco disparos

Modelo PROVENIR Humanidades Ciencias Sociales otro Temas específicos de China la puntuación media
Baichuan-13B 42.38 61.61 60.44 59.26 56.62 55.82
ChatGLM2-6B 42.55 50.98 50.99 50.80 48.37 48.80
Baichuan-7B 35.25 48.07 47.88 46.61 44.14 44.43
ChatGLM-6B 32.35 39.22 39.65 38.62 37.70 37.48
BatGPT-15B 34.96 35.45 36.31 42.14 37.89 37.16
Chino-LLaMA-13B 27.12 33.18 34.87 35.10 32.97 32.63
MOSS-SFT-16B 27.23 30.41 28.84 32.56 28.68 29.57
Chino-GLM-10B 25.49 27.05 27.42 29.21 28.05 27.26

Disparo cero

Modelo PROVENIR Humanidades Ciencias Sociales otro Temas específicos de China la puntuación media
Baichuan-13B 42.04 60.49 59.55 56.60 55.72 54.63
ChatGLM2-6B 41.28 52.85 53.37 52.24 50.58 49.95
Baichuan-7B 32.79 44.43 46.78 44.79 43.11 42.33
ChatGLM-6B 32.22 42.91 44.81 42.60 41.93 40.79
BatGPT-15B 33.72 36.53 38.07 46.94 38.32 38.51
Chino-LLaMA-13B 26.76 26.57 27.42 28.33 26.73 27.34
MOSS-SFT-16B 25.68 26.35 27.21 27.92 26.70 26.88
Chino-GLM-10B 25.57 25.01 26.33 25.94 25.81 25.80

Se puede ver que el rendimiento del modelo Baichuan-13B en chino sigue siendo muy bueno.

Parámetros del modelo Baichuan-13B

nombre del modelo Dimensión de capa oculta capas Jefes de atención tamaño del vocabulario parámetros totales datos de entrenamiento (tokens) código de localización La longitud máxima
Baichuan-7B 4,096 32 32 64.000 7,000,559,616 1,2 billones Soga 4,096
Baichuan-13B 5,120 40 40 64.000 13.264.901.120 1,4 billones Coartada 4,096

Inferencia y Despliegue

Descarga del modelo

Los pesos del modelo, el código fuente y la configuración necesarios para la inferencia se han publicado en Hugging Face: Baichuan-13B-Base y Baichuan-13B-Chat .

Puede usar el siguiente comando para descargar el modelo al local, de modo que pueda cargarlo directamente (/data/sim_chatgpt/) para un uso conveniente.

git clone https://huggingface.co/baichuan-inc/Baichuan-13B-Base
git clone https://huggingface.co/baichuan-inc/Baichuan-13B-Chat

modelo de razonamiento

Aquí utiliza directamente el medio ambiente en el almacén LLaMA-Efficient-Tuning

conda activate baichuan-7b

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from transformers.generation.utils import GenerationConfig
tokenizer = AutoTokenizer.from_pretrained("/data/sim_chatgpt/Baichuan-13B-Chat", use_fast=False, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained("/data/sim_chatgpt/Baichuan-13B-Chat", torch_dtype=torch.float16, trust_remote_code=True)
model = model.quantize(4).cuda()
model.generation_config = GenerationConfig.from_pretrained("/data/sim_chatgpt/Baichuan-13B-Chat")
messages = []
messages.append({
    
    "role": "user", "content": "世界上第二高的山峰是哪座"})
response = model.chat(tokenizer, messages)
print(response)

Dado que la memoria de la GPU es de solo 16 G, usamos directamente int4 para cuantificar, pero debido a que se cancela device_map='auto', el modelo se carga en la CPU, por lo que la velocidad es muy lenta y se informa un error.

RuntimeError: Error de CUDA: no hay ninguna imagen del kernel disponible para su ejecución
en el dispositivo

Este error debe estar relacionado con el modelo de GPU; para resolverlo, consulte
https://github.com/baichuan-inc/Baichuan-13B/issues/56

Si lo anterior es un problema de hardware, podemos considerar cargar directamente la versión cuantificada de Baichuan-13B: Baichuan-13B-Chat-8bit, y descargarla con el comando git clone.

git clone https://huggingface.co/trillionmonster/Baichuan-13B-Chat-8bit

El código de razonamiento que usa int8 es el siguiente:

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from transformers.generation.utils import GenerationConfig
tokenizer = AutoTokenizer.from_pretrained("/data/sim_chatgpt/Baichuan-13B-Chat-8bit", use_fast=False, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained("/data/sim_chatgpt/Baichuan-13B-Chat-8bit",  device_map="auto", trust_remote_code=True)
model.generation_config = GenerationConfig.from_pretrained("/data/sim_chatgpt/Baichuan-13B-Chat-8bit")
messages = []
messages.append({
    
    "role": "user", "content": "世界上第二高的山峰是哪座"})
response = model.chat(tokenizer, messages)
print(response)

Para usar el razonamiento int4, solo necesita modificar una línea de código de la siguiente manera:
(la diferencia es agregar load_in_4bit=True)

model = AutoModelForCausalLM.from_pretrained("/data/sim_chatgpt/Baichuan-13B-Chat-8bit",  device_map="auto",load_in_4bit=True,trust_remote_code=True)

Ajuste fino del proceso Baichuan-13B-Chat basado en LoRA (ronda única)

Esta referencia de puesta a punto: LLaMA-Efficient-Tuning

descargar repositorio

git clone https://github.com/hiyouga/LLaMA-Efficient-Tuning.git

Entorno de configuración

# 这里使用和 baichuan-7b 相同的环境
conda create -n baichuan-7b python=3.10
conda activate baichuan-7b
cd LLaMA-Efficient-Tuning
pip install -r requirements.txt

datos de ajuste fino

Aquí use directamente alpaca_gpt4_zh, que son los datos de alpaca china generados por GPT24, en el directorio de datos del almacén.
El formato de datos es el siguiente:

instrucción: instrucción de tarea, no puede estar vacía.
entrada: entrada de tarea, puede estar vacía. Si no está vacío, cuando los datos de entrenamiento se procesen dentro del proyecto, la instrucción y la entrada se unirán como la entrada de la tarea.
salida: salida de la tarea, no puede estar vacía.

El ejemplo de datos es el siguiente:

[ { "instruction": "Tres consejos para mantenerse saludable.", "input": "", "output": "Aquí hay tres consejos para mantenerse saludable:\n\n1. Actividad física, como caminar, correr o nadar, promueve la salud cardiovascular, fortalece los músculos y ayuda a perder peso.\n\n2. Consuma una dieta balanceada. Consuma vegetales frescos, frutas, granos integrales y alimentos bajos en grasa todos los días Alimentos con proteínas, evite los alimentos con alto contenido de azúcar , alimentos ricos en grasas y procesados ​​para mantener una dieta saludable.\n\n3. Duerma lo suficiente. El sueño es esencial para la salud humana, y los adultos deben asegurarse de dormir de 7 a 8 horas todos los días. Dormir bien ayuda a reducir el estrés y promueve la recuperación , y mejora la concentración y la memoria." }, { "instruction": "¿Cuáles son los colores primarios?", "input": "", "output": "Los colores primarios generalmente se refieren al rojo, verde y azul (RGB) Estos son los tres colores básicos que crean el color a través del principio de mezcla aditiva de colores. En dispositivos de visualización basados ​​en emisores de luz, como televisores, monitores de computadora, pantallas de teléfonos inteligentes y tabletas, los tres colores primarios se pueden mezclar para producir una gran cantidad de colores. Entre ellos, el rojo y el verde se pueden mezclar para producir amarillo, el rojo y el azul se pueden mezclar para producir magenta, y el azul y el verde se pueden mezclar para producir cian. Cuando el rojo, el verde y el azul se mezclan en proporciones iguales, pueden producir blanco o gris.\n\nAdemás, en la impresión y la pintura, los colores primarios se refieren a los colores basados ​​en pigmentos rojo, amarillo y azul (RYB). Estos tres colores se utilizan para crear colores mediante el principio de la mezcla sustractiva de colores. Sin embargo, las definiciones específicas de los tres colores primarios no son únicas, y diferentes sistemas de color pueden usar tres colores primarios diferentes". } ,










proceso de puesta a punto

El método de ajuste fino adopta el método LoRA.
Los comandos del proceso de ajuste fino son los siguientes:

CUDA_VISIBLE_DEVICES=0 nohup python src/train_bash.py \
    --do_train \
    --model_name_or_path /data/sim_chatgpt/Baichuan-13B-Chat \
    --dataset_dir data \
    --dataset alpaca_gpt4_zh \
    --output_dir baichuan_lora_checkpoint \
    --source_prefix ""  \
    --max_source_length 256 \
    --max_target_length 512 \
    --per_device_train_batch_size 1 \
    --gradient_accumulation_steps 1 \
    --lr_scheduler_type cosine \
    --logging_steps 10 \
    --save_steps 1000 \
    --learning_rate 5e-5 \
    --num_train_epochs 1.0 \
    --plot_loss \
    --fp16  \
    --lora_target W_pack \
    --lora_rank 8 \
    --padding_side right \
    --quantization_bit 4 \
    >> qlora_log_0727.out 2>&1 &

Cada parámetro se describe de la siguiente manera:

  • CUDA_VISIBLE_DEVICES=0: Operación de tarjeta única.
  • do_train: Si realizar el entrenamiento.
  • model_name_or_path: ruta del modelo previamente entrenada.
  • dataset_dir: directorio de almacenamiento de datos de entrenamiento.
  • conjunto de datos: el nombre del conjunto de datos de entrenamiento, puede agregar un conjunto de datos personalizado en data/dataset_info.json.
  • output_dir: ruta para guardar el modelo ajustado.
  • source_prefix: el prefijo agregado a cada secuencia de entrada durante el entrenamiento puede estar vacío.
  • max_source_length: la longitud máxima de la secuencia de entrada, es decir, la longitud de source_prefix + instrucción + entrada.
  • max_target_length: la longitud máxima de la secuencia de salida, es decir, la longitud de la salida.
  • per_device_train_batch_size: el tamaño del lote utilizado para el entrenamiento. Se puede configurar de acuerdo con el tamaño de la memoria GPU.
  • gradiente_accumulación_pasos: Tiempos de acumulación de gradiente.
  • logging_steps: cuántos pasos para generar un registro.
  • save_steps: cuántos pasos para guardar los parámetros.
  • learning_rate: La tasa de aprendizaje inicial para el optimizador AdamW.
  • num_train_epochs: número de rondas de entrenamiento (si no es un número entero, solo una parte de los datos se entrenarán en la última ronda)
  • plot_loss: dibuje la curva de la función de pérdida después del ajuste fino y guarde la imagen en output_dir.
  • fp16: utilice entrenamiento de precisión media (precisión mixta).
  • lora_target: el nombre del módulo en el modelo grande que será ajustado por LoRA.
  • lora_rank: tamaño de rango en el ajuste fino de LoRA.
  • padding_side: alineación del pad, izquierda o derecha.

La memoria de video ocupa alrededor de 9 G y el tiempo de ejecución es de aproximadamente 60 horas.
inserte la descripción de la imagen aquí
inserte la descripción de la imagen aquí

Probar el modelo ajustado

CUDA_VISIBLE_DEVICES=0 python finetune_lora.py \
    --do_eval \
    --model_name_or_path /data/sim_chatgpt/Baichuan-13B-Chat \
    --checkpoint_dir baichuan_lora_checkpoint \
    --dataset_dir data \
    --dataset alpaca_gpt4_zh_test \
    --output_dir baichuan_lora_eval_result \
    --per_device_eval_batch_size 4 \
    --predict_with_generate \
    --padding_side right

Cada parámetro se describe de la siguiente manera:

  • CUDA_VISIBLE_DEVICES=0: Operación de tarjeta única.
  • do_eval: si ejecutar la prueba.
  • model_name_or_path: ruta del modelo previamente entrenada.
  • checkpoint_dir: ajuste fino de la ruta del modelo.
  • dataset_dir: directorio de almacenamiento de datos de prueba.
  • conjunto de datos: el nombre del conjunto de datos de prueba; puede agregar un conjunto de datos personalizado en data/dataset_info.json.
  • output_dir: ruta para guardar los resultados de la prueba.
  • per_device_eval_batch_size: el tamaño del lote de los datos de prueba. Puede configurarlo usted mismo según el tamaño de la memoria de la GPU.
  • predict_with_generate: si generar secuencias para calcular puntajes ROUGE o BLEU.
  • padding_side: alineación del pad, izquierda o derecha.

Ajuste fino del proceso Baichuan-13B-Base basado en QLoRA (rondas múltiples)

Descarga el repositorio del proyecto Firefly

git clone https://github.com/yangjianxin1/Firefly.git
cd Firefly

Preparar conjunto de datos

Puede usar los datos dummy_data.jsonl debajo de los datos en el proyecto para la depuración de código, un total de 33 piezas de datos. Los datos de entrenamiento reales utilizan los datos de diálogo de múltiples rondas proporcionados por MOSS: moss-003-sft-data.
Hay un total de 671 000 piezas de
datos Dirección de descarga de datos: https://huggingface.co/datasets/YeungNLP/moss-003-sft-data
Método de descarga: git clone https://huggingface.co/datasets/YeungNLP/moss -003- datos sft

Descripción del conjunto de datos: cada fila es un diálogo de múltiples rondas, donde se requiere el campo de conversación y se pueden agregar o eliminar otros campos según las necesidades reales.
Un ejemplo de datos es el siguiente:

{
    
    
    "conversation_id":44,
    "category":"Brainstorming",
    "conversation":[
        {
    
    
            "human":"怎么能够有效地提升个人能力？",
            "assistant":"提升个人能力可以通过以下几个方面实现：\n\n1. 学习新知识和技能：阅读相关书籍、参加课程和工作坊、观看教育视频等学习方式，可以帮助你掌握新的知识和技能，从而提升个人能力。\n\n2. 持续练习和实践：不断地练习和实践所学的知识和技能，可以帮助你更好地掌握和应用这些技能，提高你的表现和效率。\n\n3. 寻求反馈和改进：寻求他人的反馈和建议可以帮助你发现自己的不足之处，进一步完善和改进自己的能力。\n\n4. 建立良好的工作和生活习惯：建立良好的工作和生活习惯，如合理安排时间、注意健康、保持积极态度等，可以提高你的工作效率和生活品质，从而提升个人能力。\n\n5. 社交和交流：与他人交流和合作，可以帮助你更好地了解他人的观点和经验，从而提升自己的能力和见识。"
        },
        {
    
    
            "human":"对于初学者来说，如何快速掌握编程技能？",
            "assistant":"以下是几个建议，可以帮助初学者快速掌握编程技能：\n\n1. 学习基础知识：建议先学习编程语言的基础知识和语法，例如变量、数据类型、控制结构、函数等。可以通过在线课程、编程书籍、视频教程等方式学习。\n\n2. 实践编程：进行实际的编程练习是非常重要的，可以通过参加编程挑战、编写小项目等方式来进行实践。\n\n3. 寻求反馈：可以寻求他人的反馈和建议，例如在线编程社区、编程导师等，他们可以帮助你发现问题并及时纠正。\n\n4. 阅读优秀代码：阅读和分析优秀的代码可以帮助你学习其他程序员的编程思路和技巧，从而提高自己的编程能力。\n\n5. 不断学习和更新：编程技术和工具在不断更新和发展，因此需要不断学习新的知识和技能，例如学习新的编程语言、框架、工具等，以跟上技术的发展和变化。\n\n总之，学习编程需要耐心和坚持，并且需要不断地实践和学习。通过以上建议，可以帮助初学者快速掌握编程技能。"
        },
        {
    
    
            "human":"除了参加编程挑战和阅读代码，还有哪些方式可以提升自己的编程能力呢？",
            "assistant":"除了参加编程挑战和阅读代码，还有以下几种方式可以提升自己的编程能力：\n\n1. 参与开源项目：加入一个开源项目，可以让你了解到实际的软件开发流程和团队合作方式，并且可以与其他开发人员合作，学习和分享编程技巧和经验。\n\n2. 进行代码重构：对已经编写的代码进行重构，可以帮助你了解更好的编程实践和设计模式，从而提高代码的可读性和可维护性。\n\n3. 练习算法和数据结构：算法和数据结构是编程中的重要基础，练习算法和数据结构可以帮助你了解不同的数据结构和算法，从而更好地解决实际问题。\n\n4. 学习软件工程和架构：学习软件工程和架构的知识，可以帮助你了解如何设计和构建可靠、可扩展和可维护的软件系统。\n\n5. 参加编程社区和论坛：参加编程社区和论坛可以让你与其他开发人员分享和讨论编程经验和技巧，了解最新的技术趋势和解决方案。\n\n总之，提升编程能力需要不断地学习和实践，并与其他开发人员和编程专家进行交流和合作，以获取更多的经验和知识。"
        },
        {
    
    
            "human":"你有没有推荐的编程挑战网站？",
            "assistant":"当然，以下是一些值得推荐的编程挑战网站：\n\n1. HackerRank：HackerRank 是一个全球领先的技术招聘平台，提供数百种编程挑战和比赛，包括算法、数据结构、数学、SQL、AI 等多个技术领域。\n\n2. LeetCode：LeetCode 是一个在线编程学习和实践平台，提供数千道编程题目，主要涵盖算法和数据结构。\n\n3. Codeforces：Codeforces 是一个全球知名的编程竞赛网站，提供数百个比赛和练习题目，主要涵盖算法和数据结构。\n\n4. Codewars：Codewars 是一个在线编程学习和实践平台，提供数千道编程题目，主要涵盖算法、数据结构、面向对象编程等多个技术领域。\n\n5. Project Euler：Project Euler 是一个非营利性的在线编程挑战平台，提供一系列数学和计算机科学问题，需要用编程语言进行解答。\n\n以上这些编程挑战网站可以帮助你提高编程能力，并且可以与其他编程爱好者进行交流和竞争。"
        },
        {
    
    
            "human":"在学习编程的过程中，如何避免陷入困境和放弃呢？",
            "assistant":"学习编程是一个需要长期坚持和不断学习的过程，以下是一些避免陷入困境和放弃的方法：\n\n1. 制定合理的学习计划：制定合理的学习计划，包括学习时间、学习内容、目标等，可以帮助你更好地管理时间和精力，避免学习过程中的松懈和分心。\n\n2. 寻找合适的学习资源：选择适合自己的学习资源，例如在线课程、编程书籍、视频教程等，可以让你更好地了解和掌握编程知识和技能。\n\n3. 寻求帮助和支持：在学习过程中，遇到问题和困难是很正常的，可以寻求他人的帮助和支持，例如参加编程社区、找到编程导师等。\n\n4. 进行实践和项目：实践和项目是学习编程的重要组成部分，可以帮助你更好地了解和掌握编程技能，同时也可以提高学习的兴趣和动力。\n\n5. 坚持并保持兴趣：坚持学习和保持兴趣是学习编程的关键。可以通过参加编程社区、参加编程竞赛、与其他编程爱好者交流等方式来保持兴趣和动力。\n\n总之，学习编程需要耐心和坚持，并需要不断学习和实践。通过以上方法可以帮助你避免陷入困境和放弃。"
        }
    ],
}

Configurar parámetros de entrenamiento

Todas las configuraciones de parámetros de entrenamiento se almacenan en el directorio train_args para facilitar la gestión unificada. Tome el ajuste fino de Baichuan-13B como ejemplo, su archivo de configuración de parámetros de entrenamiento es train_args/qlora/baichuan-13b-sft-qlora.json, puede modificar los parámetros de entrenamiento en el archivo según la situación.

Los parámetros de entrenamiento se describen a continuación:

  • output_dir: directorio de salida de entrenamiento, punto de control de almacenamiento, tokenizador, tensorboard, etc.
  • model_name_or_path: El directorio local del modelo previamente entrenado, o el nombre del modelo en huggingface.
  • train_file: ruta del conjunto de datos de entrenamiento. Puede usar data/dummy_data.jsonl para la depuración o especificarlo como un archivo de capacitación local.
  • num_train_epochs: rondas de entrenamiento. Si la cantidad de datos es lo suficientemente grande, generalmente se recomienda entrenar solo una época.
  • per_device_train_batch_size: el tamaño del lote de cada tarjeta gráfica.
  • gradiente_accumulación_pasos: Pasos de acumulación de gradiente. lote global=num_gpus * per_device_train_batch_size * gradiente_accumulation_steps.
  • gradiente_punto de control: si la memoria de video está estirada, se puede encender. El tiempo se intercambia por espacio, el modelo no almacena en caché el estado de activación y el cálculo de reenvío se realizará dos veces para ahorrar memoria de video. Lo habilitamos de manera predeterminada.
  • learning_rate: tasa de aprendizaje. Al ajustar los parámetros completos, se recomienda que sean más pequeños, 1e-5 o 5e-6. Durante el entrenamiento de qlora, se recomienda configurarlo en 2e-4 o 1e-4 según el tamaño del modelo.
  • max_seq_length: La longitud máxima durante el entrenamiento. Configúrelo de acuerdo con su propio dispositivo, cuanto más tarde, más memoria de video necesitará.
  • logging_steps: cuántos pasos para imprimir la pérdida del tren, el resultado se imprimirá en el registro y se guardará en el tensorboard.
  • save_steps: cuántos pasos para guardar el modelo cada vez.
  • save_total_limit: el número máximo de puntos de control guardados en el directorio output_dir, y el punto de control más antiguo se eliminará si se excede.
  • lr_scheduler_type: estrategia de variación de la tasa de aprendizaje.
  • warmup_steps: pasos de calentamiento. Cuántos pasos atraviesa la tasa de aprendizaje para aumentar hasta el valor especificado.
  • optim: optimizador. Para un ajuste fino completo de los parámetros, se recomienda utilizar adamw_hf. Si se trata de un ajuste fino de qlora, se recomienda utilizar paged_adamw_32bit.
  • semilla: semilla aleatoria, utilizada para reproducir los resultados experimentales.
  • fp16: Usar precisión mixta fp16. Se recomienda habilitarlo para V100.
  • bf16: Usar precisión mixta fp16. Se recomienda habilitar A100.
  • lora_rank: El rango de la matriz qlora. Generalmente fijado en 8, 16, 32, 64, etc., el autor lo puso en 64 en el artículo de qlora. Cuanto mayor sea el valor, mayor será la cantidad de parámetros involucrados en el entrenamiento; en términos generales, el efecto será mejor, pero se requiere más memoria de video.
  • lora_alpha: parámetro de escalado en qlora. Generalmente, se puede establecer en 16 o 32.
  • lora_dropout: La tasa de abandono del peso lora.

Los parámetros se establecen de la siguiente manera:

{
    
    
    "output_dir": "output/baichuan-13b",
    "model_name_or_path": "/data/sim_chatgpt/Baichuan-13B-Base",
    "train_file": "./data/moss-003-sft-data.jsonl",
    "num_train_epochs": 1,
    "per_device_train_batch_size": 6,
    "gradient_accumulation_steps": 2,
    "learning_rate": 1e-4,
    "max_seq_length": 900,
    "logging_steps": 300,
    "save_steps": 500,
    "save_total_limit": 1,
    "lr_scheduler_type": "constant_with_warmup",
    "warmup_steps": 3000,
    "lora_rank": 64,
    "lora_alpha": 16,
    "lora_dropout": 0.05,
​
    "gradient_checkpointing": true,
    "disable_tqdm": false,
    "optim": "paged_adamw_32bit",
    "seed": 42,
    "fp16": true,
    "report_to": "tensorboard",
    "dataloader_num_workers": 5,
    "save_strategy": "steps",
    "weight_decay": 0,
    "max_grad_norm": 0.3,
    "remove_unused_columns": false
}

proceso de puesta a punto

Ejecute el siguiente script para iniciar el entrenamiento, como es una sola tarjeta, el comando es el siguiente:

python train_qlora.py --train_args_file train_args/qlora/baichuan-13b-sft-qlora.json

En caso de varias tarjetas:

torchrun --nproc_per_node={
    
    num_gpus} train_qlora.py --train_args_file train_args/qlora/baichuan-13b-sft-qlora.json

fusionar peso

modelo de razonamiento

Referencia: https://zhuanlan.zhihu.com/p/643950663
https://github.com/yangjianxin1/Firefly
Baichuan-13B Inicio rápido de ajuste fino de LoRA

Supongo que te gusta

Origin blog.csdn.net/dzysunshine/article/details/131810629
Recomendado
Clasificación
Diario
Más
2024-07-25(0)
2024-07-24(0)
2024-07-23(0)
2024-07-22(0)
2024-07-21(0)
2024-07-20(0)
2024-07-19(0)
2024-07-18(0)
2024-07-17(0)
2024-07-16(0)

Code World

© 2018 codetd.com