Annuaire d'articles
1. Contexte du modèle financier
- Le secteur financier a besoin de LLM dans le domaine vertical, car il existe une sécurité financière et la plupart des données sont stockées localement, et il existe des exigences en matière de contrôle des risques, de précision et de performances en temps réel.
- (1) BloombergGPT avec 50 milliards de paramètres
- Le grand modèle financier BloombergGPT utilise également l'architecture du transformateur et la route du décodeur pour construire le plus grand ensemble de données financières FINPILE à l'heure actuelle, qui est une formation hybride de texte général + connaissances financières.
- 512 GPU A100 de 40 Go ont été utilisés et 4 modèles ont été sauvegardés pendant la formation, et chaque modèle a été divisé en 128 GPU.
- (2) Du Xiaoman May [Grand Modèle Yuanxuan]
- En utilisant la méthode de réglage hybride, le premier grand modèle financier avec 100 milliards de paramètres
- Dans l'évaluation générale des capacités, Xuanyuan a dépassé ChatGPT 3,5 dans 10,2 % des tâches et l'a égalé dans 61,22 % des tâches, impliquant 13 dimensions principales telles que le calcul mathématique, l'écriture de scènes, le raisonnement logique et la synthèse de texte.
- Scène d'atterrissage GPT grand modèle financier :
- Classification du sentiment d'actualité ——> Les institutions financières jugent leurs points de vue sur un événement, aidant les stratégies quantitatives et les décisions d'investissement
- Quiz sur les connaissances financières --> aider les institutions financières à évaluer le crédit, sélectionner les actions conceptuelles et aider les analystes à apprendre les domaines professionnels
- Analyse des états financiers et audit comptable ——> Générer des rapports d'analyse financière et des prospectus pour aider la comptabilité et l'audit
2. Questions de recherche sur les grands modèles
- La base théorique du LLM :
- 如Few/Zero-Shot Learning、In-Context Learning、Chain-of-Thought能力；
- Zero-shot est un échantillon qui n'a pas été exposé à cette catégorie lors de la formation du modèle, mais il peut toujours classer des catégories qui n'ont pas été vues ; peu de coups signifie qu'il n'y a qu'un petit nombre d'échantillons dans chaque catégorie. On espère qu'après que le modèle ait appris une grande quantité de données d'une certaine catégorie, un petit nombre d'exemples de données de nouvelles classes peut apprendre rapidement. Few-show est une sorte de méta-apprentissage.
- Architecture de réseau : architecture de transformateur, comprenant des modules communs tels que la segmentation des mots, la méthode de normalisation, la position de normalisation, le codage de position, l'attention et le biais. Existe-t-il une meilleure architecture que le transformateur Si certains chercheurs s'inspirent de la direction des mathématiques, ils proposent un cadre de réseau de collecteurs spatiaux non euclidiens.
- Calcul efficace de grands modèles : parallélisme de modèles, déchargement de tenseurs, déchargement d'optimiseurs, etc., deepspeed de Microsoft et autres outils
- Efficacité du raisonnement : model pruning, distillation des connaissances, quantification des paramètres, etc.
- Adaptation efficace de grands modèles pour les tâches en aval :
- apprentissage rapide apprentissage rapide : par exemple, ajustement des instructions
- Ajustement efficace des paramètres : n'ajustez qu'un petit nombre de paramètres dans le grand modèle
- Génération contrôlable de grands modèles : contrôlez la génération de modèles grâce au réglage fin des instructions, à l'ingénierie rapide, à la chaîne de réflexion, au RLHF, etc.
- Problèmes éthiques : les méthodes d'alignement telles que RLHF et RLAIF améliorent la qualité de la production
- Évaluation des modèles : évaluation des questions d'examen professionnel, modèles plus solides pour noter les petits modèles, évaluation manuelle, etc.
3. Parcours technologique des modèles à grande échelle
- Le PEFT de Hugging Face est une bibliothèque (LoRA est l'une de ses technologies prises en charge, en plus de Prefix Tuning, P-Tuning, Prompt Tuning), qui vous permet d'utiliser divers modèles de langage basés sur Transformer pour un réglage fin efficace.
- AIpaca alpaca : laissez le modèle text-davinci-003 d'OpenAI générer 52 000 échantillons de suivi d'instructions de manière auto-instruite en tant que données d'entraînement d'Alpaca. L'alpaga formé final ne comporte que 7 B paramètres. Les optimisations peuvent être affinées à l'aide de LoRA.
- Idées techniques LLM :
- Modèle de langage : lama, bloom, glm, etc.
- Données de réglage fin des instructions : alpaca_data, bella_data, guanaco_data, etc. À l'heure actuelle, les données de réglage fin des instructions reposent fortement sur les données d'auto-instruction d'alpaca et de chatgpt. Le traitement des données se réfère à la figure ci-dessus
- Accélération de réglage fin : lora (comme Alpaca-Lora), etc., vous pouvez également utiliser la bibliothèque peft, la boîte à outils de quantification bitsandbytes, deepspeed (lire d'abord puis s'engager dans ColossalAI
torch.distributed), le modèle de quantification llama.cpp. Avant que la méthode LoRA ne soit proposée, il existait de nombreuses méthodes pour tenter de résoudre le dilemme du réglage fin des grands modèles. Il existe deux directions principales :- Ajoutez la couche adaptatrice. L'adaptateur consiste à fixer les paramètres d'origine et à ajouter des paramètres supplémentaires pour un réglage fin ;
- en raison d'une certaine forme d'activation de la couche d'entrée.
- Méthodes d'optimisation de la formation : quantification, parallélisme 3D, déchargement du processeur
4. Modèle de famille LLaMA
5. Le principe de mise au point du modèle Lora
- L'essence de l'invite est l'apprentissage efficace des paramètres (PEL), car la formation à la mise à jour complète des paramètres PLM prend du temps, tandis que dans l'apprentissage efficace des paramètres, les grands modèles n'ont besoin que de spécifier ou d'ajouter un petit nombre de paramètres pouvant être formés et de geler d'autres paramètres. pour améliorer l'efficacité de la formation et assurer la qualité
- Lora adaptation de bas rang, adaptation de bas rang, introduit en outre une matrice de décomposition de bas rang entraînable et fixe le poids de pré-entraînement en même temps. La matrice décomposée est apprise par rétropropagation, décomposant la nouvelle matrice de poids adaptée à la tâche en une matrice de faible dimension (plus petite) sans perdre trop d'informations.
- La nouvelle matrice de poids lora peut être combinée avec les poids de pré-formation d'origine, et aucune surcharge supplémentaire ne sera générée dans l'inférence ; comme le montre la figure ci-dessus, les poids du modèle de pré-formation sont sur la gauche, et l'entrée et les dimensions de sortie sont toutes deux d, qui sont gelées pendant l'apprentissage. , le côté droit utilise une initialisation gaussienne aléatoire pour A, et B vaut initialement 0 pendant l'apprentissage. Une matrice de pondération pré-entraînée, représentée par une décomposition de rang inférieur, initialement △W=BA : h = W 0 x + Δ W x = W 0 x + BA xh=W_0 x+\Delta W x=W_0 x+BA xh=O0X+∆W x _=O0X+B A x
- Principe LoRA : c'est-à-dire ajouter une matrice supplémentaire de rang inférieur aux paramètres spécifiés sur le grand modèle de langage, et former uniquement les paramètres supplémentaires pendant le processus de formation du modèle. Lorsque la "valeur de rang" est beaucoup plus petite que la dimension de paramètre d'origine, les paramètres de matrice de rang inférieur nouvellement ajoutés sont très petits, de sorte que seul un petit nombre de paramètres peut être formé pour obtenir des résultats correspondants.
- Le gel des poids de modèle pré-formés et l'injection d'une matrice de décomposition de rang entraînable dans chaque poids de la couche Transformer réduisent considérablement le nombre de paramètres entraînables pour les tâches en aval. En fait, la "branche latérale" sur le côté droit est ajoutée, c'est-à-dire, utilisez d'abord une couche linéaire A pour réduire les données de la dimension d à r, puis utilisez la deuxième couche linéaire B pour modifier les données de r à dimension d. Enfin, les résultats des parties gauche et droite sont additionnés et fusionnés pour obtenir la sortie
hidden_state.
- Indicateurs d'évaluation du texte généré par LLM : perplexité, BLEU et ROUGE, etc.
- Alpaca-Lora : basé sur
le lien du projet de réglage fin LLaMA (7B) : https://github.com/tloen/alpaca-lora
weight address : https://huggingface.co/decapoda-research/llama-7b-hf- La raison de la naissance du projet : l'alpaga Stanford Alpaca est affiné sur l'ensemble du modèle LLaMA, c'est-à-dire que tous les paramètres du modèle pré-entraîné sont affinés (ajustement complet). Cependant, cette méthode nécessite toujours un coût matériel élevé et une faible efficacité de formation. LLaMA n'a pas été affiné par les instructions et l'effet de génération est médiocre
- Par conséquent, Alpaca-Lora : Utiliser la technologie Lora, dans le cas du gel des paramètres LLaMA du modèle d'origine, en ajoutant des couches réseau supplémentaires au modèle, et en formant uniquement ces nouveaux paramètres de couche réseau. En raison du petit nombre de ces nouveaux paramètres, non seulement le coût de réglage fin est considérablement réduit (en utilisant une carte graphique RTX 4090, il ne faut que 5 heures pour former un modèle comparable à Alpaca, ce qui réduit la demande de puissance de calcul de ce type de modèle de qualité grand public) peut également obtenir des effets similaires à un réglage fin complet.
- Convertissez l'horloge LLaMA d'origine au format de fichier de modèle correspondant à la bibliothèque de transformateurs (vous pouvez également télécharger le modèle converti directement à partir de huggingface, reportez-vous à )
- Utilisez LoRA (Low-rank Adaptation) pour affiner le modèle et l'inférence du modèle
- Réintégrez les pondérations LoRA dans le modèle de base pour l'exportation au format HuggingFace et PyTorch state_dicts. pour aider les utilisateurs qui veulent exécuter l'inférence dans des projets comme llama.cpp ou alpaca.cpp
6. Réglage fin réel de Lora basé sur mt0-large
- Prenons l'exemple du modèle mt0-large pour lora :
- Sélectionnez la tâche d'analyse des sentiments dans le domaine financier
financial_sentiment_analysis, étant donné une phrase, il est nécessaire d'identifier laquelle des trois phrases est négative, positive ou neutre
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]]]
- Ensuite,
peftajustez avec l'aide de la bibliothèque (Parameter-Efficient Fine-Tuning), qui prend en charge le réglage suivant :- Réglage de l'adaptateur (fixez les paramètres du modèle pré-formé d'origine et ajustez uniquement le nouvel adaptateur)
- Réglage du préfixe (construisez une section de jetons virtuels liés à la tâche en tant que préfixe avant de saisir le jeton, et ne mettez à jour les paramètres quel que soit le préfixe pendant la formation, tandis que les autres paramètres du transformateur sont fixes, similaires à la construction de l'invite, sauf que le l'invite est construite artificiellement et ne peut pas être mise à jour des paramètres pendant la formation du modèle, et le préfixe peut apprendre l'invite <implicite>)
- Prompt Tuning (version simplifiée de Prefix Tuning, ajoutant uniquement des jetons d'invite dans la couche d'entrée, n'a pas besoin d'ajouter MLP)
- P-tuning (transforme l'invite en une couche d'intégration apprenable, la v2 ajoute des jetons d'invite en entrée)
- LoRA (Low-Rank Adaptation, afin de résoudre le problème que l'adaptateur augmente la profondeur du modèle et augmente le temps de raisonnement du modèle, l'invite dans le réglage ci-dessus est plus difficile à former et réduit la longueur de séquence disponible du modèle)
- Cette méthode peut ajouter directement les deux matrices AB formées aux paramètres du modèle de pré-formation d'origine lors de l'inférence, et remplacer les paramètres du modèle de pré-formation d'origine par le résultat de l'addition.
- Équivalent à la simulation du processus de réglage complet avec 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()
Vous pouvez voir que les LoraConfigparamètres ci-dessus sont les suivants :
peft_config = LoraConfig(task_type=TaskType.SEQ_2_SEQ_LM,
inference_mode=False,
r=8,
lora_alpha=32,
lora_dropout=0.1)
task_type: type de tâche :
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: rang de lora ; lora_A est initialisé avec une distribution gaussienne, lora_B est initialisé à 0lora_alpha: facteur d'échelle pour le réglage fin de loralora_dropout: coefficient d'abandon pour le réglage fin de loralearning_rate: Le taux d'apprentissage initial de l'optimiseur adamw
Voir aussi LoraConfigles attributs dans la définition de classe :
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) : dimension d'attention Lora. - target_modules (
Union[List[str],str]): Les noms des modules auxquels appliquer Lora. - lora_alpha (
float): Le paramètre alpha pour la mise à l'échelle Lora. - lora_dropout (
float): La probabilité d'abandon pour les couches Lora. - fan_in_fan_out (
bool): Définissez ceci sur True si la couche à remplacer stocke le poids comme (fan_in, fan_out).- Par exemple, gpt-2 utilise
Conv1Dqui stocke des poids tels que (fan_in, fan_out) et doit donc être défini surTrue.:
- Par exemple, gpt-2 utilise
- biais (
str) : Type de biais pour Lora. Peut être 'aucun', 'tous' ou 'lora_only' - modules_to_save (
List[str]): Liste des modules en dehors des couches LoRA à définir comme pouvant être entraînés
et enregistrés au point de contrôle final.
La définition de la couche Lora_layer spécifique est la suivante, lora est exécuté dans la classe d'intégration personnalisée (classe d'intégration personnalisée, héritage nn.embeddinget loralayerclasse)
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])
Référence
[1] A Survey of Large Language Models. Wayne Xin Zhao
[2] Introduction to large model papers
[3] Les modèles de type LLaMA ne sont pas si difficiles, LoRA réduit le réglage fin du modèle à quelques heures
[4] Principe de l'algorithme PPO dans RLHF et sa réalisation
[5] Formation ChatGPT basée sur DeepSpeed
[6] Prompt-Tuning - Interprétation approfondie d'un nouveau paradigme de réglage fin
[7] Résumé des principes de la technologie de réglage fin efficace des grands paramètres de modèle (7) - Meilleure pratique et Résumé
[8] chatGLM2-6B Ajustement complet des paramètres du modèle (amélioration de la qualité des interactions de dialogue à plusieurs tours, etc.) : https://github.com/SpongebBob/Finetune-ChatGLM2-6B
[9] Large astuce de construction d'échantillon de réglage fin du modèle
[10] Principe technique du réglage fin efficace des paramètres du modèle à grande échelle - Tableau) [
11] Ajustement de la formation de grands modèles. Aucune donnée n'est pas intelligente
[12] Comprendre les rapports financiers : utiliser de grands modèles. Aucun Les données ne sont pas intelligentes
[13] Réduire pour augmenter : un guide pour l'efficacité des paramètres Réglage fin
[14]Réglage fin à faible ressource de grands modèles : analyse des idées de modèles LoRA et implémentation du code BLOOM-LORA
[15] méthodes de réglage fin du modèle et des instructions. Shanding Xijing
[16] discute de la formation de modèles à grande échelle et de la technologie d'optimisation des inférences
[17] Principe de la technologie d'accélération de réglage fin LLM + LoRa et pratique pratique basée sur PEFT : Quelques réflexions et un cas complet de mt0-large + lora
[18] Voyons si l'accélération du réglage fin Lora à grande échelle est efficace : Performance comparaison entre le réglage fin des paramètres complets à paramètres complets et le réglage fin de bas rang LoRA Introduction aux expériences open
- source
20] Analyse de la réalisation de l'extraction d'attributs d'entités basée sur le modèle de dialogue GLM-6B : Quelques réflexions sur l'apprentissage zéro-shot et en contexte
[21] Pratique de réglage fin : DeepSpeed + Transformers permet de démarrer facilement et rapidement avec des dizaines de milliards d'ajustement du modèle de paramètres
[22] LLaMA : modèle de langage de base ouvert et efficace avec de petits paramètres + grandes données Notes de lecture
[23] Modèle de langage LLaMA du point de vue du code
[24] Analyse rapide du côté application ChatGPT : à partir de Concepts, de base
composition, tâches courantes, stratégies de construction d'outils open source et d'ensembles de données
Parler des composants de base du système de réponse aux questions de la base de connaissances du plug-in de grand modèle langchain : comment mieux analyser et segmenter le texte non structuré complexe
[27] Regardez le modèle ChatGLM2-6B qui prend en charge le contexte 32K : une brève description des points d'optimisation et généraliser les points d'optimisation de la formation
des modèles open source existants 30] https://github.com/mymusise/ ChatGLM-Tuning est une implémentation abordable de Chatgpt, basée sur ChatGLM-6B+ LoRA de Tsinghua pour un réglage fin [31] https://github.com/jxhe/unify-parameter-efficient- tuning [31] Analyse simple de la méthode LoRA [32] financial_phrasebank dataset.huggingface [33] Pratique de déploiement de la localisation Alpaca-lora du modèle de langage GPT.