Análisis de código fuente de razonamiento de sintonización ChatGLM-6B

from peft import LoraConfig, get_peft_model, TaskType

def load_lora_config(model):
    config = LoraConfig(
        task_type=TaskType.CAUSAL_LM,
        inference_mode=False,
        r=8,
        lora_alpha=32,
        lora_dropout=0.1,
        target_modules=["query_key_value"]
    )
    return get_peft_model(model, config)


tokenizer = AutoTokenizer.from_pretrained("../ChatGLM-Tuning-master/chatglm-6b", trust_remote_code=True)
from transformers import AutoModel
import torch


model = AutoModel.from_pretrained("../ChatGLM-Tuning-master/chatglm-6b", trust_remote_code=True).half().cuda()

from peft import PeftModel
model = PeftModel.from_pretrained(model, "../ChatGLM-Tuning-master/output").half()

Este código implica principalmente el procesamiento de tareas y la inferencia utilizando el modelo PEFT (Transformadores eficientes en paralelo) . La función del código se explica línea por línea a continuación:

1. Importe las bibliotecas y módulos necesarios:

   javascriptCopiar código

   from peft import LoraConfig, get_peft_model, TaskType

   Esta línea de código importa funciones relacionadas como LoraConfig, get_peft_modely .TaskType

2. Defina la función para cargar la configuración del modelo PEFT:

   arduinoCopiar código

   def load_lora_config(model):
       config = LoraConfig(
           task_type=TaskType.CAUSAL_LM,
           inference_mode=False,
           r=8,
           lora_alpha=32,
           lora_dropout=0.1,
           target_modules=["query_key_value"]
       )
       return get_peft_model(model, config)

   La función toma un modelargumento y crea un objeto con LoraConfigla clase que especifica el tipo de tarea como (modelo de lenguaje causal ), el modo de inferencia como , 8 como argumento, 32 como argumento , 0.1 como argumento . Luego use la función pasando y como parámetros para devolver el modelo PEFT .configTaskType.CAUSAL_LMFalserlora_alphalora_dropouttarget_modules["query_key_value"]get_peft_modelmodelconfig

3. Importe las bibliotecas y módulos necesarios:

   pythonCopiar código

   tokenizer = AutoTokenizer.from_pretrained("../ChatGLM-Tuning-master/chatglm-6b", trust_remote_code=True)
   from transformers import AutoModel
   import torch
   
   
   model = AutoModel.from_pretrained("../ChatGLM-Tuning-master/chatglm-6b", trust_remote_code=True).half().cuda()
   

   Esta sección importa las bibliotecas y módulos necesarios como AutoTokenizerclases y AutoModelclases y crea un tokenizerobjeto.

4. Cargue un modelo preentrenado:

   scssCopiar código

   model = AutoModel.from_pretrained("../ChatGLM-Tuning-master/chatglm-6b", trust_remote_code=True).half().cuda()

   Esta línea de código usa AutoModella clase para cargar el modelo del modelo previamente entrenado de la ruta especificada, y .half()convierte el modelo en una representación numérica de coma flotante de precisión media a través del método, y luego usa el método para .cuda()mover el modelo a la GPU

5. Importe las bibliotecas y módulos necesarios:

   javascriptCopiar código

   from peft import PeftModel

   Esta línea de código importa PeftModella clase.

6. Cargue el modelo PEFT:

   makefileCopiar código

   model = PeftModel.from_pretrained(model, "../ChatGLM-Tuning-master/output").half()

   Esta línea de código usa PeftModella clase para cargar el modelo PEFT desde la salida de la ruta especificada, y .half()el método convierte el modelo en una representación de coma flotante de precisión media.

Resumen: esta pieza de código completa principalmente la operación de cargar el modelo PEFT y las configuraciones relacionadas, incluida la creación de LoraConfigobjetos, la carga del modelo previamente entrenado, la conversión del modelo a un número de punto flotante de precisión media y, finalmente, la devolución del modelo PEFT.

1. El módulo importado en el código peftes un módulo personalizado que proporciona funciones relacionadas con el modelo PEFT.

2. load_lora_configmodelLa función crea un objeto basado en el parámetro entrante LoraConfigy establece algunos parámetros, como tipo de tarea, modo de inferencia, rvalor, lora_alphavalor, lora_dropoutvalor y módulo de destino, etc. Luego llame a get_peft_modella función, pasando modely config, para devolver el modelo PEFT.

3. tokenizerEl objeto AutoTokenizer.from_pretrainedcarga el tokenizador preentrenado desde el modelo preentrenado de la ruta especificada a través del método.

4. Use AutoModel.from_pretrainedel método para cargar el modelo previamente entrenado desde el modelo previamente entrenado en la ruta especificada, y use .half()el método para convertir el modelo en una representación numérica de punto flotante de precisión media, y luego use el método para .cuda()mover el modelo a la GPU

5. La clase es importada PeftModel.

6. PeftModel.from_pretrainedEl método se utiliza para cargar el modelo PEFT y los parámetros que se pasan incluyen el modelo cargado previamente modely la salida de la ruta especificada. Este método devuelve un modelo PEFT y .half()el modelo se convierte en una representación de punto flotante de precisión media a través del método.

Resumen: este código completa principalmente la operación de cargar el modelo PEFT y las configuraciones relacionadas, incluida la creación de LoraConfigobjetos, la carga de modelos y tokenizadores previamente entrenados, la conversión del modelo a números de punto flotante de precisión media y, finalmente, la devolución del modelo PEFT. Estas operaciones implican pasos como la configuración del modelo, la carga del tokenizador, la carga y la conversión del modelo, y se utilizan para preparar y configurar el entorno del modelo PEFT.

1. El en el código importa el y en el from peft import LoraConfig, get_peft_model, TaskTypemódulo personalizado .peftLoraConfigget_peft_modelTaskType

2. load_lora_configLa función se utiliza para cargar el objeto LoraConfig, que es la configuración del modelo PEFT. En la función, se crea un LoraConfigobjeto configy se configura el modelo estableciendo diferentes valores de parámetros. Entre los parámetros están:

• task_type=TaskType.CAUSAL_LM: especifica que el tipo de tarea es un modelo de lenguaje causal.
• inference_mode=False: especifique el modo de inferencia como modo de no inferencia, es decir, modo de entrenamiento.
• r=8: especifica un valor r de 8 para el modelo PEFT.
• lora_alpha=32: especifique un valor lora_alpha de 32 para el modelo PEFT.
• lora_dropout=0.1: especifique un valor de lora_dropout de 0,1 para el modelo PEFT.
• target_modules=["query_key_value"]: especifica el módulo de destino del modelo PEFT como "query_key_value".

Luego, llame a get_peft_modella función, pase modely configy devuelva el modelo PEFT configurado.

1. tokenizerEl objeto usa AutoTokenizer.from_pretrainedel método para cargar el tokenizador previamente entrenado desde el modelo previamente entrenado en la ruta especificada. trust_remote_code=TrueIndica que el código remoto es de confianza.

2. from transformers import AutoModelLa clase se importa AutoModel, que se usa para cargar el modelo preentrenado.

3. modelEl objeto AutoModel.from_pretrainedcarga el modelo preentrenado del modelo preentrenado de la ruta especificada a través del método y usa .half()el método para convertir el modelo en una representación de punto flotante de precisión media. Luego, use .cuda()para mover el modelo a la GPU.

4. from peft import PeftModelpeftImportado de un módulo personalizado PeftModel.

5. modelEl objeto PeftModel.from_pretrainedcarga el modelo PEFT desde la salida de la ruta especificada a través del método y .half()convierte el modelo en una representación de punto flotante de precisión media utilizando el método.

Resumen: la función de este código es cargar el modelo PEFT y configurar los parámetros relacionados, incluida la creación de LoraConfigobjetos, la carga de modelos y tokenizadores previamente entrenados, la conversión del modelo a números de punto flotante de precisión media y, finalmente, la devolución del modelo PEFT configurado. Estas operaciones implican pasos como la configuración del modelo, la carga del tokenizador, la carga y la conversión del modelo, y se utilizan para preparar y configurar el entorno del modelo PEFT.