Directorio de artículos
1. Antecedentes del modelo financiero
- La industria financiera necesita LLM en el campo vertical, porque hay seguridad financiera y la mayoría de los datos se almacenan localmente, y existen requisitos para el control de riesgos, precisión y rendimiento en tiempo real.
- (1) BloombergGPT con 50 mil millones de parámetros
- El gran modelo financiero de BloombergGPT también utiliza la arquitectura del transformador y la ruta del decodificador para crear el mayor conjunto de datos financieros FINPILE en la actualidad, que es una formación híbrida de texto general + conocimiento financiero.
- Se utilizaron 512 GPU A100 de 40 GB, y se realizaron copias de seguridad de 4 modelos durante el entrenamiento, y cada modelo se dividió en 128 GPU.
- (2) [Modelo grande de Yuanxuan] de Du Xiaoman May
- Usando el método de ajuste híbrido, el primer gran modelo financiero con 100 mil millones de parámetros
- En la evaluación de habilidad general, Xuanyuan superó a ChatGPT 3.5 en el 10.2 % de las tareas y lo igualó en el 61.22 % de las tareas, involucrando 13 dimensiones principales como cálculo matemático, escritura de escenas, razonamiento lógico y resumen de texto.
- Escena de aterrizaje de modelo grande financiero GPT:
- Clasificación de sentimiento de noticias ——> Las instituciones financieras juzgan sus puntos de vista sobre un evento, lo que ayuda a las estrategias cuantitativas y las decisiones de inversión.
- Cuestionario de conocimientos financieros --> ayudar a las instituciones financieras en la evaluación crediticia, evaluar acciones conceptuales y ayudar a los analistas a aprender campos profesionales
- Análisis de estados financieros y auditoría contable ——> Generar informes y prospectos de análisis financiero para ayudar a la contabilidad y la auditoría
2. Preguntas de investigación sobre modelos grandes
- La base teórica de LLM:
- 如 Pocos/aprendizaje de tiro cero, aprendizaje en contexto, cadena de pensamiento能力;
- Zero-shot es una muestra que no ha sido expuesta a esta categoría en el entrenamiento de modelos, pero aún puede clasificar categorías que no se han visto, few-shot es que solo hay una pequeña cantidad de muestras en cada categoría. que después de que el modelo aprende una gran cantidad de datos de una determinada categoría, para una pequeña cantidad de datos de muestra de nuevas clases puede aprender rápidamente. Few-show es una especie de meta-aprendizaje.
- Arquitectura de red: Arquitectura de transformador, incluidos módulos comunes como segmentación de palabras, método de normalización, posición de normalización, codificación de posición, atención y sesgo. ¿Existe una arquitectura mejor que el transformador? Si algunos académicos se inspiran en la dirección de las matemáticas, proponen un marco de red múltiple de espacio no euclidiano.
- Computación eficiente de modelos grandes: paralelismo de modelos, descarga de tensores, descarga de optimizador, etc., Deepspeed de Microsoft y otras herramientas
- Eficiencia de razonamiento: poda de modelos, destilación de conocimiento, cuantificación de parámetros, etc.
- Adaptación eficiente de modelos grandes para tareas posteriores:
- aprendizaje rápido aprendizaje rápido: como el ajuste fino de las instrucciones
- Ajuste fino eficiente de los parámetros: solo ajuste una pequeña cantidad de parámetros en el modelo grande
- Generación controlable de modelos grandes: generación de modelos de control mediante ajuste fino de instrucciones, ingeniería rápida, cadena de pensamiento, RLHF, etc.
- Cuestiones éticas: Los métodos de alineación como RLHF y RLAIF mejoran la calidad de la generación
- Evaluación de modelos: evaluación de preguntas de examen profesional, modelos más fuertes para calificar modelos pequeños, evaluación manual, etc.
3. Ruta de tecnología modelo a gran escala
- Hugging Face's PEFT es una biblioteca (LoRA es una de sus tecnologías compatibles, además de Prefix Tuning, P-Tuning, Prompt Tuning), que le permite usar varios modelos de lenguaje basados en Transformer para un ajuste fino eficiente.
- AIpaca alpaca: Deje que el modelo text-davinci-003 de OpenAI genere 52K muestras de seguimiento de instrucciones de manera autoinstruccional como datos de entrenamiento de Alpaca. La alpaca entrenada final tiene solo 7B parámetros. Las optimizaciones se pueden ajustar utilizando LoRA.
- Ideas técnicas LLM:
- Modelo de lenguaje: llama, bloom, glm, etc.
- Datos de ajuste de instrucción: alpaca_data, bella_data, guanaco_data, etc. En la actualidad, los datos de ajuste fino de las instrucciones dependen en gran medida de los datos de autoinstrucción de alpaca y chatgpt. El procesamiento de datos se refiere a la figura anterior
- Aceleración de ajuste fino: lora (como Alpaca-Lora), etc., también puede usar la biblioteca peft, bits y bytes del kit de herramientas de cuantificación, velocidad profunda (leer primero y luego
torch.distributedparticipar en ColossalAI), modelo de cuantificación llama.cpp. Antes de que se propusiera el método LoRA, había muchos métodos para tratar de resolver el dilema del ajuste fino de modelos grandes. Hay dos direcciones principales:- Agregue la capa del adaptador. El adaptador es para arreglar los parámetros originales y agregar algunos parámetros adicionales para el ajuste fino;
- debido a alguna forma de activación de la capa de entrada.
- Métodos de optimización de entrenamiento: cuantificación, paralelismo 3D, descarga de CPU
4. Modelo de familia LLaMA
5. El principio del ajuste fino del modelo Lora
- La esencia del aviso es el aprendizaje eficiente de parámetros (PEL), porque el entrenamiento de actualización de parámetros completos de PLM requiere mucho tiempo, mientras que en el aprendizaje eficiente de parámetros, los modelos grandes solo necesitan especificar o agregar una pequeña cantidad de parámetros entrenables y congelar otros parámetros. para mejorar la eficiencia de la formación y garantizar la calidad
- La adaptación de rango bajo de Lora, la adaptación de rango bajo, además introduce una matriz de descomposición de rango bajo entrenable y fija el peso previo al entrenamiento al mismo tiempo. La matriz descompuesta se aprende mediante retropropagación, descomponiendo la nueva matriz de peso adaptada a la tarea en una matriz de baja dimensión (más pequeña) sin perder demasiada información.
- La nueva matriz de peso de lora se puede combinar con los pesos originales de preentrenamiento y no se generará una sobrecarga adicional en la inferencia; como se muestra en la figura anterior, los pesos del modelo de preentrenamiento están a la izquierda y la entrada y las dimensiones de salida son ambas d, que se congelan durante el entrenamiento. , el lado derecho usa una inicialización gaussiana aleatoria para A, y B es inicialmente 0 durante el entrenamiento. Una matriz de peso previamente entrenada, representada por una descomposición de rango bajo, inicialmente △W=BA: h = W 0 x + Δ W x = W 0 x + BA xh=W_0 x+\Delta W x=W_0 x+BA xh=W0X+Δ ancho x=W0X+B A x
- Principio de LoRA: es decir, agregue una matriz adicional de rango bajo a los parámetros especificados en el modelo de lenguaje grande y solo entrene los parámetros adicionales durante el proceso de entrenamiento del modelo. Cuando el "valor de rango" es mucho más pequeño que la dimensión del parámetro original, los parámetros de matriz de rango bajo recién agregados son muy pequeños, por lo que solo se puede entrenar una pequeña cantidad de parámetros para obtener los resultados correspondientes.
- Congelar los pesos del modelo previamente entrenados e inyectar una matriz de descomposición de rango entrenable en cada peso de la capa del Transformador reduce en gran medida la cantidad de parámetros entrenables para las tareas posteriores. De hecho, se agrega la "rama lateral" en el lado derecho, es decir, primero use una capa A lineal para reducir los datos de la dimensión d a r, y luego use la segunda capa B lineal para cambiar los datos de r nuevamente a dimensión d. Finalmente, los resultados de las partes izquierda y derecha se suman y fusionan para obtener la salida
hidden_state.
- Indicadores para evaluar texto generado por LLM: perplejidad, BLEU y ROUGE, etc.
- Alpaca-Lora: basado en
el proyecto de ajuste fino LLaMA (7B) enlace: https://github.com/tloen/alpaca-lora
dirección de peso: https://huggingface.co/decapoda-research/llama-7b-hf- El motivo del nacimiento del proyecto: la alpaca Stanford Alpaca está afinada en todo el modelo LLaMA, es decir, todos los parámetros en el modelo pre-entrenado están afinados (full fine-tuning). Sin embargo, este método aún requiere un alto costo de hardware y una baja eficiencia de entrenamiento. LLaMA no se ha ajustado con instrucciones y el efecto de generación es pobre
- Por lo tanto, Alpaca-Lora: Usando la tecnología Lora, en el caso de congelar los parámetros LLaMA del modelo original, agregando capas de red adicionales al modelo, y solo entrenando estos nuevos parámetros de capa de red. Debido a la pequeña cantidad de estos nuevos parámetros, no solo se reduce significativamente el costo del ajuste fino (usando una tarjeta gráfica RTX 4090, se necesitan solo 5 horas para entrenar un modelo comparable a Alpaca, lo que reduce la demanda de poder de cómputo de este tipo de modelo a grado de consumidor) también puede lograr efectos similares al ajuste completo.
- Convierta el reloj LLaMA original al formato de archivo del modelo correspondiente a la biblioteca de transformadores (también puede descargar el modelo convertido directamente desde huggingface, consulte )
- Use LoRA (adaptación de bajo rango) para ajustar el modelo y la inferencia del modelo
- Vuelva a incorporar los pesos de LoRA en el modelo base para exportarlos al formato HuggingFace y PyTorch state_dicts. para ayudar a los usuarios que quieren ejecutar inferencias en proyectos como llama.cpp o alpaca.cpp
6. Ajuste fino real de Lora basado en mt0-large
- Tomemos como ejemplo el modelo mt0-large para lora:
- Seleccione la tarea de análisis de sentimientos en el ámbito financiero
financial_sentiment_analysis, dada una oración, se requiere identificar cuál de las tres oraciones es negativa, positiva o neutra
next(iter(train_dataloader)).keys()
Out[2]: dict_keys(['input_ids', 'attention_mask', 'labels'])
# train_dataset.data如下所示
input_ids: [[[486,7834,304,259,35610,...,0,0,0,0,0],[259,229832,259,277,263,...,0,0,0,0,0],...,[259,96890,259,5330,259,...,0,0,0,0,0],[486,5835,259,39509,259,...,0,0,0,0,0]],[[1494,1546,259,69541,259,...,0,0,0,0,0],[486,7495,13159,339,2847,...,0,0,0,0,0],...,[20871,72726,702,92223,332,...,0,0,0,0,0],[486,584,193394,347,11470,...,0,0,0,0,0]],[[274,298,259,62434,263,...,0,0,0,0,0],[1477,514,1904,259,263,...,0,0,0,0,0],...,[143129,268,259,277,263,...,0,0,0,0,0],[35446,339,31499,285,288,...,0,0,0,0,0]]]
attention_mask: [[[1,1,1,1,1,...,0,0,0,0,0],[1,1,1,1,1,...,0,0,0,0,0],...,[1,1,1,1,1,...,0,0,0,0,0],[1,1,1,1,1,...,0,0,0,0,0]],[[1,1,1,1,1,...,0,0,0,0,0],[1,1,1,1,1,...,0,0,0,0,0],...,[1,1,1,1,1,...,0,0,0,0,0],[1,1,1,1,1,...,0,0,0,0,0]],[[1,1,1,1,1,...,0,0,0,0,0],[1,1,1,1,1,...,0,0,0,0,0],...,[1,1,1,1,1,...,0,0,0,0,0],[1,1,1,1,1,...,0,0,0,0,0]]]
labels: [[[59006,1,-100],[59006,1,-100],...,[59006,1,-100],[59006,1,-100]],[[18205,1,-100],[59006,1,-100],...,[259,32588,1],[18205,1,-100]],[[59006,1,-100],[59006,1,-100],...,[59006,1,-100],[59006,1,-100]]]
- A continuación,
peftajuste con la ayuda de la biblioteca (ajuste fino de eficiencia de parámetros), que admite el siguiente ajuste:- Adaptación del adaptador (fija los parámetros del modelo original preentrenado y solo afina el nuevo adaptador)
- Ajuste de prefijo (construya una sección de tokens virtuales relacionados con tareas como un prefijo antes de ingresar el token, y solo actualice los parámetros independientemente del prefijo durante el entrenamiento, mientras que otros parámetros del transformador son fijos, similar a la construcción del aviso, excepto que el la solicitud se construye artificialmente y no se puede actualizar los parámetros durante el entrenamiento del modelo, y el prefijo puede aprender la solicitud <implícita>)
- Prompt Tuning (versión simplificada de Prefix Tuning, solo agrega tokens de solicitud en la capa de entrada, no necesita agregar MLP)
- P-tuning (transformar el aviso en una capa de incrustación aprendible, v2 agrega tokens de avisos como entrada)
- LoRA (adaptación de rango bajo, para resolver el problema de que el adaptador aumenta la profundidad del modelo y aumenta el tiempo de razonamiento del modelo, el mensaje en el ajuste anterior es más difícil de entrenar y reduce la longitud de secuencia disponible del modelo)
- Este método puede agregar directamente las dos matrices AB entrenadas a los parámetros del modelo de preentrenamiento original durante la inferencia, y reemplazar los parámetros del modelo de preentrenamiento original con el resultado de la suma.
- Equivale a simular el proceso de sintonización completa con LoRA
# !/usr/bin/python
# -*- coding: utf-8 -*-
"""
@Author : guomiansheng
@Software : Pycharm
@Contact : [email protected]
@File : main.py
"""
from transformers import AutoModelForSeq2SeqLM
from peft import get_peft_config, get_peft_model, get_peft_model_state_dict, LoraConfig, TaskType
import torch
from datasets import load_dataset
import os
os.environ["TOKENIZERS_PARALLELISM"] = "false"
from transformers import AutoTokenizer
from torch.utils.data import DataLoader
from transformers import default_data_collator, get_linear_schedule_with_warmup
from tqdm import tqdm
from datasets import load_dataset
def train_model():
# device = "cuda"
device = "mps"
model_name_or_path = "bigscience/mt0-large"
tokenizer_name_or_path = "bigscience/mt0-large"
checkpoint_name = "financial_sentiment_analysis_lora_v1.pt"
text_column = "sentence"
label_column = "text_label"
max_length = 128
lr = 1e-3
num_epochs = 3
batch_size = 8
# 搭建model
peft_config = LoraConfig(task_type=TaskType.SEQ_2_SEQ_LM, inference_mode=False, r=8, lora_alpha=32,
lora_dropout=0.1)
model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path)
model = get_peft_model(model, peft_config)
model.print_trainable_parameters()
# 加载数据
dataset = load_dataset("financial_phrasebank", "sentences_allagree")
dataset = dataset["train"].train_test_split(test_size=0.1)
dataset["validation"] = dataset["test"]
del dataset["test"]
classes = dataset["train"].features["label"].names
dataset = dataset.map(
lambda x: {
"text_label": [classes[label] for label in x["label"]]},
batched=True,
num_proc=1,
)
# 训练数据预处理
tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)
def preprocess_function(examples):
inputs = examples[text_column]
targets = examples[label_column]
model_inputs = tokenizer(inputs, max_length=max_length, padding="max_length", truncation=True,
return_tensors="pt")
labels = tokenizer(targets, max_length=3, padding="max_length", truncation=True, return_tensors="pt")
labels = labels["input_ids"]
labels[labels == tokenizer.pad_token_id] = -100
model_inputs["labels"] = labels
return model_inputs
processed_datasets = dataset.map(
preprocess_function,
batched=True,
num_proc=1,
remove_columns=dataset["train"].column_names,
load_from_cache_file=False,
desc="Running tokenizer on dataset",
)
train_dataset = processed_datasets["train"]
eval_dataset = processed_datasets["validation"]
train_dataloader = DataLoader(
train_dataset, shuffle=True, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True
)
eval_dataloader = DataLoader(eval_dataset, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True)
# 设定优化器和正则项
optimizer = torch.optim.AdamW(model.parameters(), lr=lr)
lr_scheduler = get_linear_schedule_with_warmup(
optimizer=optimizer,
num_warmup_steps=0,
num_training_steps=(len(train_dataloader) * num_epochs),
)
# 训练和评估
model = model.to(device)
for epoch in range(num_epochs):
model.train()
total_loss = 0
for step, batch in enumerate(tqdm(train_dataloader)):
batch = {
k: v.to(device) for k, v in batch.items()}
outputs = model(**batch)
loss = outputs.loss
total_loss += loss.detach().float()
loss.backward()
optimizer.step()
lr_scheduler.step()
optimizer.zero_grad()
model.eval()
eval_loss = 0
eval_preds = []
for step, batch in enumerate(tqdm(eval_dataloader)):
batch = {
k: v.to(device) for k, v in batch.items()}
with torch.no_grad():
outputs = model(**batch)
loss = outputs.loss
eval_loss += loss.detach().float()
eval_preds.extend(
tokenizer.batch_decode(torch.argmax(outputs.logits, -1).detach().cpu().numpy(),
skip_special_tokens=True)
)
eval_epoch_loss = eval_loss / len(eval_dataloader)
eval_ppl = torch.exp(eval_epoch_loss)
train_epoch_loss = total_loss / len(train_dataloader)
train_ppl = torch.exp(train_epoch_loss)
print(f"{
epoch=}: {
train_ppl=} {
train_epoch_loss=} {
eval_ppl=} {
eval_epoch_loss=}")
# 保存模型
peft_model_id = f"{
model_name_or_path}_{
peft_config.peft_type}_{
peft_config.task_type}"
model.save_pretrained(peft_model_id)
def inference_model():
# device = "cuda"
device = "mps"
model_name_or_path = "bigscience/mt0-large"
tokenizer_name_or_path = "bigscience/mt0-large"
checkpoint_name = "financial_sentiment_analysis_lora_v1.pt"
text_column = "sentence"
label_column = "text_label"
max_length = 128
lr = 1e-3
num_epochs = 3
batch_size = 8
# 搭建model
peft_config = LoraConfig(task_type=TaskType.SEQ_2_SEQ_LM, inference_mode=False, r=8, lora_alpha=32,
lora_dropout=0.1)
model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path)
model = get_peft_model(model, peft_config)
model.print_trainable_parameters()
# 加载数据
dataset = load_dataset("financial_phrasebank", "sentences_allagree")
dataset = dataset["train"].train_test_split(test_size=0.1)
dataset["validation"] = dataset["test"]
del dataset["test"]
classes = dataset["train"].features["label"].names
dataset = dataset.map(
lambda x: {
"text_label": [classes[label] for label in x["label"]]},
batched=True,
num_proc=1,
)
# 训练数据预处理
tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)
def preprocess_function(examples):
inputs = examples[text_column]
targets = examples[label_column]
model_inputs = tokenizer(inputs, max_length=max_length, padding="max_length", truncation=True,
return_tensors="pt")
labels = tokenizer(targets, max_length=3, padding="max_length", truncation=True, return_tensors="pt")
labels = labels["input_ids"]
labels[labels == tokenizer.pad_token_id] = -100
model_inputs["labels"] = labels
return model_inputs
processed_datasets = dataset.map(
preprocess_function,
batched=True,
num_proc=1,
remove_columns=dataset["train"].column_names,
load_from_cache_file=False,
desc="Running tokenizer on dataset",
)
train_dataset = processed_datasets["train"]
eval_dataset = processed_datasets["validation"]
train_dataloader = DataLoader(
train_dataset, shuffle=True, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True
)
eval_dataloader = DataLoader(eval_dataset, collate_fn=default_data_collator, batch_size=batch_size, pin_memory=True)
# 设定优化器和正则项
optimizer = torch.optim.AdamW(model.parameters(), lr=lr)
lr_scheduler = get_linear_schedule_with_warmup(
optimizer=optimizer,
num_warmup_steps=0,
num_training_steps=(len(train_dataloader) * num_epochs),
)
# 训练和评估
model = model.to(device)
# 模型推理预测
from peft import PeftModel, PeftConfig
peft_model_id = f"{
model_name_or_path}_{
peft_config.peft_type}_{
peft_config.task_type}"
config = PeftConfig.from_pretrained(peft_model_id)
model = AutoModelForSeq2SeqLM.from_pretrained(config.base_model_name_or_path)
model = PeftModel.from_pretrained(model, peft_model_id)
model.eval()
i = 0
inputs = tokenizer(dataset["validation"][text_column][i], return_tensors="pt")
print(dataset["validation"][text_column][i])
print(inputs)
with torch.no_grad():
outputs = model.generate(input_ids=inputs["input_ids"], max_new_tokens=10)
print(outputs)
print(tokenizer.batch_decode(outputs.detach().cpu().numpy(), skip_special_tokens=True))
print("=============test=============")
if __name__ == '__main__':
# train_model()
inference_model()
Puede ver que los LoraConfigparámetros anteriores son los siguientes:
peft_config = LoraConfig(task_type=TaskType.SEQ_2_SEQ_LM,
inference_mode=False,
r=8,
lora_alpha=32,
lora_dropout=0.1)
task_type: tipo de tarea:
class TaskType(str, enum.Enum):
SEQ_CLS = "SEQ_CLS" 常规分类任务
SEQ_2_SEQ_LM = "SEQ_2_SEQ_LM" seq2seq任务
CAUSAL_LM = "CAUSAL_LM" LM任务
TOKEN_CLS = "TOKEN_CLS" token的分类任务：序列标注之类的
inference_mode：r: rango de lora; lora_A se inicializa con distribución gaussiana, lora_B se inicializa con 0lora_alpha: factor de escala para el ajuste fino de loralora_dropout: coeficiente de abandono para el ajuste fino de loralearning_rate: La tasa de aprendizaje inicial del optimizador adamw
Ver también LoraConfiglos atributos en la definición de clase:
class LoraConfig(PeftConfig):
r: int = field(default=8, metadata={
"help": "Lora attention dimension"})
target_modules: Optional[Union[List[str], str]] = field(
default=None,
metadata={
"help": "List of module names or regex expression of the module names to replace with Lora."
"For example, ['q', 'v'] or '.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$' "
},
)
lora_alpha: int = field(default=None, metadata={
"help": "Lora alpha"})
lora_dropout: float = field(default=None, metadata={
"help": "Lora dropout"})
fan_in_fan_out: bool = field(
default=False,
metadata={
"help": "Set this to True if the layer to replace stores weight like (fan_in, fan_out)"},
)
bias: str = field(default="none", metadata={
"help": "Bias type for Lora. Can be 'none', 'all' or 'lora_only'"})
modules_to_save: Optional[List[str]] = field(
default=None,
metadata={
"help": "List of modules apart from LoRA layers to be set as trainable and saved in the final checkpoint. "
"For example, in Sequence Classification or Token Classification tasks, "
"the final layer `classifier/score` are randomly initialized and as such need to be trainable and saved."
},
)
init_lora_weights: bool = field(
default=True,
metadata={
"help": "Whether to initialize the weights of the Lora layers."},
)
def __post_init__(self):
self.peft_type = PeftType.LORA
- r (
int): Dimensión de atención de Lora. - target_modules (
Union[List[str],str]): los nombres de los módulos a los que aplicar Lora. - lora_alpha (
float): El parámetro alfa para el escalado de Lora. - lora_dropout (
float): la probabilidad de abandono de las capas de Lora. - fan_in_fan_out (
bool): configúrelo en Verdadero si la capa a reemplazar almacena peso como (fan_in, fan_out).- Por ejemplo, gpt-2 usa
Conv1Dlos pesos de las tiendas como (fan_in, fan_out) y, por lo tanto, debe establecerse enTrue.:
- Por ejemplo, gpt-2 usa
- bias (
str): Tipo de bias para Lora. Puede ser 'ninguno', 'todos' o 'lora_only' - module_to_save (
List[str]):Lista de módulos aparte de las capas de LoRA que se configurarán como entrenables
y se guardarán en el punto de control final.
La definición de la capa Lora_layer específica es la siguiente, lora se ejecuta en la clase de incrustación personalizada (clase de incrustación personalizada, herencia nn.embeddingy loralayerclase)
class LoraLayer:
def __init__(
self,
in_features: int,
out_features: int,
):
self.r = {
}
self.lora_alpha = {
}
self.scaling = {
}
self.lora_dropout = nn.ModuleDict({
})
self.lora_A = nn.ModuleDict({
})
self.lora_B = nn.ModuleDict({
})
# For Embedding layer
self.lora_embedding_A = nn.ParameterDict({
})
self.lora_embedding_B = nn.ParameterDict({
})
# Mark the weight as unmerged
self.merged = False
self.disable_adapters = False
self.in_features = in_features
self.out_features = out_features
def update_layer(self, adapter_name, r, lora_alpha, lora_dropout, init_lora_weights):
self.r[adapter_name] = r
self.lora_alpha[adapter_name] = lora_alpha
if lora_dropout > 0.0:
lora_dropout_layer = nn.Dropout(p=lora_dropout)
else:
lora_dropout_layer = nn.Identity()
self.lora_dropout.update(nn.ModuleDict({
adapter_name: lora_dropout_layer}))
# Actual trainable parameters
if r > 0:
self.lora_A.update(nn.ModuleDict({
adapter_name: nn.Linear(self.in_features, r, bias=False)}))
self.lora_B.update(nn.ModuleDict({
adapter_name: nn.Linear(r, self.out_features, bias=False)}))
self.scaling[adapter_name] = lora_alpha / r
if init_lora_weights:
self.reset_lora_parameters(adapter_name)
self.to(self.weight.device)
def update_layer_embedding(self, adapter_name, r, lora_alpha, lora_dropout, init_lora_weights):
self.r[adapter_name] = r
self.lora_alpha[adapter_name] = lora_alpha
if lora_dropout > 0.0:
lora_dropout_layer = nn.Dropout(p=lora_dropout)
else:
lora_dropout_layer = nn.Identity()
self.lora_dropout.update(nn.ModuleDict({
adapter_name: lora_dropout_layer}))
# Actual trainable parameters
if r > 0:
self.lora_embedding_A.update(
nn.ParameterDict({
adapter_name: nn.Parameter(self.weight.new_zeros((r, self.in_features)))})
)
self.lora_embedding_B.update(
nn.ParameterDict({
adapter_name: nn.Parameter(self.weight.new_zeros((self.out_features, r)))})
)
self.scaling[adapter_name] = lora_alpha / r
if init_lora_weights:
self.reset_lora_parameters(adapter_name)
self.to(self.weight.device)
def reset_lora_parameters(self, adapter_name):
if adapter_name in self.lora_A.keys():
# initialize A the same way as the default for nn.Linear and B to zero
nn.init.kaiming_uniform_(self.lora_A[adapter_name].weight, a=math.sqrt(5))
nn.init.zeros_(self.lora_B[adapter_name].weight)
if adapter_name in self.lora_embedding_A.keys():
# initialize a the same way as the default for nn.linear and b to zero
nn.init.zeros_(self.lora_embedding_A[adapter_name])
nn.init.normal_(self.lora_embedding_B[adapter_name])
Referencia
[1] A Survey of Large Language Models. Wayne Xin Zhao
[2] Introducción a los documentos de modelos grandes
[3] Los modelos similares a LLaMA no son tan difíciles, LoRA reduce el ajuste del modelo a unas pocas horas
[4] Principio del algoritmo PPO en RLHF y su realización
[5] Entrenamiento ChatGPT basado en DeepSpeed
[6] Prompt-Tuning - Interpretación profunda de un nuevo paradigma de ajuste fino
[7] Resumen de los principios de la tecnología de ajuste fino eficiente de parámetros de modelo grande (7) - Mejores prácticas y Resumen
[8] chatGLM2-6B Ajuste completo de parámetros del modelo (mejora de la calidad de las interacciones de diálogo de múltiples rondas, etc.): https://github.com/SpongebBob/Finetune-ChatGLM2-6B
[9] Grande ajuste fino del modelo truco de construcción de muestras
[10] Principio técnico del ajuste fino eficiente de los parámetros del modelo a gran escala Resumen (1) - Introducción al ajuste fino de parámetros de fondo y eficiente (comparación del ajuste fino de parámetros completo y (Tabla) [
11] Ajuste fino del entrenamiento de modelos grandes. Sin datos no es inteligente
[12] Comprensión de los informes financieros: uso de modelos grandes. Ninguno Los datos no son inteligentes
[13] De reducción a escala ascendente: una guía para la eficiencia de parámetros Ajuste fino
[14]Ajuste fino de modelos grandes con pocos recursos: análisis de las ideas del modelo LoRA e implementación del código BLOOM-LORA
[15] Métodos de ajuste fino de instrucciones y modelos Shanding Xijing
[16] analiza en detalle el entrenamiento de modelos a gran escala y la tecnología de optimización de inferencias
[ 17] Principio de la tecnología de aceleración de ajuste fino LLM+LoRa y práctica práctica basada en PEFT: algunas ideas y un caso completo de mt0-large+lora
[18] Veamos si la aceleración del ajuste fino de Lora a gran escala es efectiva : Comparación de rendimiento entre el ajuste fino de parámetro completo de parámetros completos y el ajuste fino de rango bajo de LoRA Introducción a los experimentos de
código abierto implementación
[20] Análisis de realización de la extracción de atributos de entidad basada en el modelo de diálogo GLM-6B: algunas reflexiones sobre Zero-shot y aprendizaje en contexto
[21] Práctica de ajuste fino: DeepSpeed+Transformers hace que sea fácil y rápido comenzar con decenas de miles de millones de ajustes del modelo de parámetros
[22] LLaMA: Modelo de lenguaje básico abierto y eficiente con pequeños parámetros + big data Notas de lectura
[23] Modelo de lenguaje LLaMA desde la perspectiva del código
[24] Análisis rápido del lado de la aplicación ChatGPT: de Conceptos , composición básica, tareas comunes, estrategias de construcción para herramientas de código abierto y conjuntos de datos
[25] LLM combat: gran modelo de lenguaje BLOOM herramienta de razonamiento práctica de prueba y registro de análisis de efectos
[26]Hablando sobre los componentes centrales del sistema de respuesta a preguntas de la base de conocimiento del complemento de modelo grande de langchain: cómo analizar y segmentar mejor el texto complejo no estructurado [27]
Mire el modelo ChatGLM2-6B que admite el contexto de 32K: una breve descripción de los Puntos de optimización de capacitación principales de los modelos de código abierto existentes Descripción general
[28] Cómo ajustar modelos grandes en condiciones de recursos extremadamente bajos: pensamiento del modelo LoRA y análisis de implementación de código BLOOM-LORA
[29] El poder de la escala para el ajuste rápido de parámetros eficientes
[ 30] https://github.com/mymusise/ ChatGLM-Tuning
es una implementación asequible de Chatgpt, basada en ChatGLM-6B+ LoRA de Tsinghua para afinar
[31] https://github.com/jxhe/unify-parameter-ficient- ajuste
[31] Análisis simple del método LoRA
[32] conjunto de datos de financial_phrasebank.huggingface
[33] Modelo de lenguaje grande GPT Práctica de implementación de localización Alpaca-lora Tecnología A Dong