使用QLoRA對Llama 2進行微調是我們常用的一個方法，但是在微調時會遇到各種各樣的問題，所以在本文中，將嘗試以詳細注釋的方式給出一些常見問題的答案。這些問題是特定于代碼的，大多數注釋都是針對所涉及的開源庫以及所使用的方法和類的問題。

導入庫

對于大模型，第一件事是又多了一些不熟悉的Python庫。

!pip install -q peft==0.4.0 bitsandbytes==0.40.2 transformers==4.31.0 trl==0.4.7

我們必須首先安裝accelerate, peft, bitsandbytes, transformers和trl。除了transformers，其他的庫都很陌生

transformers是這里最古老的庫，PyPI上最早的版本(2.0.0)可以追溯到2019年。它是huggingface發布的庫，可以快速訪問文本，圖像和音頻(從hugs的API下載)的機器學習模型。它還提供訓練和微調模型的功能，并可以HuggingFace模型中心共享這些模型。

庫沒有像Pytorch或Tensorflow那樣從頭開始構建神經網絡的抽象層和模塊，它提供了專門針對模型進行優化的訓練和推理api。transformer是用于LLM微調的關鍵Python庫之一，因為目前大部分的LLM都是可以通過它來加載使用。

bitsandbytes是一個相對較新的庫，PyPI上最早的版本時2021年發布的。它是CUDA自定義函數的輕量級包裝，專門為8位優化器、矩陣乘法和量化而設計。它主要提供了優化和量化模型的功能，特別是對于llm和transformers模型。它還提供了8位Adam/AdamW、 SGD momentum、LARS、LAMB等函數。bitsandbytes的目標是通過8位操作實現高效的計算和內存使用從而使llm更易于訪問。

通過利用8位優化和量化技術可以提高模型的性能和效率。在較小尺寸的消費類gpu(如RTX 3090)上運行llm存在內存瓶頸。所以人們一直對試圖減少運行llm的內存需求的權重量化技術進行研究。bitsandbytes的想法是量化模型權重的浮點精度，從較大的精度點(如FP32)到較小的精度點(如Int8) (4x4 Float16)。

有一些技術可以將FP32量化為Int8，包括abmax和零點量化，但由于這些技術的局限性，bitsandbytes庫的創建者共同撰寫了LLM.int8()論文以及8位優化器，為llm提供有效的量化方法。所以由于bitsandbytes庫提供的量化技術，這在很大程度上讓我們在消費級的GPU上可以微調更大的模型。

Peft允許我們減少將LLM(或其部分)加載到工作內存中以進行微調的內存需求。與使用較小深度學習模型的遷移學習技術不同，在遷移學習技術中，我們需要凍結像AlexNet這樣的神經網絡的較低層，然后在新任務上對分類層進行完全微調，而使用llm進行這種微調的成本是巨大的。Parameter Efficient Fine-Tuning(PEFT)方法是一組使llm適應下游任務的方法，例如在內存受限的設備(如T4GPU 提供16GB VRAM)上進行摘要或問答。

通過Peft對LLM的部分進行微調，仍然可以獲得與完全微調相比的結果。如LoRA和Prefix Tuning是相當成功的。peft庫是一個HuggingFace庫，它提供了這些微調方法，這是一個可以追溯到2023年1月的新庫。在本文中我們將使用QLoRA，這是一種用于量化llm的低秩自適應或微調技術。

trl是另一個HuggingFace庫，trl其實是自2021年發布的，但是在2023年1月才被人們熱傳。TRL是Transformer Reinforcement Learning的縮寫也就是Transformer 強化學習。它提供了在訓練和微調LLM的各個步驟中的不同算法的實現。包括監督微調步驟(SFT)，獎勵建模步驟(RM)和近端策略優化(PPO)步驟。trl也將peft作為一個依賴項，所以可以使用帶有peft方法(例如LoRA)的SFT訓練器。

dataset雖然沒有包含在我們之前的安裝包列表中(這是因為它是transformers的一個依賴項)，但dataset庫是huggingface生態系統中的另一個重要部分。它可以方便的訪問HuggingFace托管的許多公共數據集，也就是說省去了我們自己寫dataset和dataloader的時間。

上面這些庫對于LLM的任何工作都是至關重要的。這里做了一個簡單的圖片來總結這些庫是如何組合在一起的。

下面讓我們看一下導入

import os
 import torch
 from datasets import load_dataset
 from transformers import (
     AutoModelForCausalLM,
     AutoTokenizer,
     BitsAndBytesConfig,
     TrainingArguments,
     pipeline,
     logging,
 )
 from peft import LoraConfig, PeftModel
 from trl import SFTTrainer

我們繼續分析導入

torch是我們很熟悉的深度學習庫，這里我們不需要torch的那些低級功能，但是它是transformers和trl的依賴，在這里我們需要使用torch來獲取dtypes(數據類型)，比如torch.Float16以及檢查GPU的工具函數。

load_dataset所做的就是加載數據集，但是它從HuggingFace數據集中心下載到本地。所以這是一個在線加載程序，但它既高效又簡單，只需要一行代碼。

dataset = load_dataset(dataset_name, split="train")

因為模型很多所以transformer庫提供了一組稱為Auto classes的類，這些類給出了預訓練模型的名稱/路徑，它可以自動推斷出正確的結構并檢索相關模型。這個AutoModelForCausalLM是一個通用的Auto類，用于加載用于因果語言建模的模型。

對于transformers，HuggingFace提供了兩種類型的語言建模，因果和掩碼掩蔽。因果語言模型包括;GPT-3和Llama，這些模型預測標記序列中的下一個標記，以生成與輸入數據語義相似的文本。AutoModelForCausalLM類將從模型中心檢索因果模型，并加載模型權重，從而初始化模型。from_pretrained()方法為我們完成了這項工作。

model_name = "NousResearch/Llama-2-7b-chat-hf"
 model = AutoModelForCausalLM.from_pretrained(
     model_name,
     device_map=device_map
 )

AutoTokenizer是對文本數據進行標記化。它提供了一種無需顯式指定標記器類就可以初始化和使用不同模型的標記器的方便的方法。它也是一個通用的Auto類，所以它可以根據提供的模型名稱或路徑自動選擇適當的標記器。

標記器將輸入文本轉換為標記，這些標記是NLP模型使用的基本文本單位。它還提供了額外的功能，如填充、截斷和注意力掩碼等。AutoTokenizer簡化了為NLP任務對文本數據進行標記的過程。我們可以看到在下面初始化AutoTokenizer，后面我們會使用SFTTrainer將初始化的AutoTokenizer作為參數。

model_name = "NousResearch/Llama-2-7b-chat-hf"
 # Load LLaMA tokenizer
 tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)

BitsAndBytesConfig，前面已經說了我們使用bitsandbytes進行量化。transformer庫最近添加了對bitsandbytes的全面支持，因此使用BitsandBytesConfig可以配置bitsandbytes提供的任何量化方法，例如LLM.int8、FP4和NF4。將量化配置傳遞給AutoModelForCausalLM初始化器，這樣在加載模型權重時就會直接使用量化的方法。

#bits and byte config
 bnb_config = BitsAndBytesConfig(
     load_in_4bit=use_4bit,
     bnb_4bit_quant_type=bnb_4bit_quant_type,
     bnb_4bit_compute_dtype=compute_dtype,
     bnb_4bit_use_double_quant=use_nested_quant,
 )
 
 model = AutoModelForCausalLM.from_pretrained(
     model_name,
     quantization_config=bnb_config, #pass to AutoModelForCausalLM
     device_map=device_map
 )

TrainingArguments非常簡單。它用于存儲SFTTrainer的所有訓練參數。SFFTrainer接受不同類型的參數，TrainingArguments幫助我們將所有相關的訓練參數組織到一個數據類中保持代碼的整潔和有組織。

還有一些很好的工具類可以與TrainingArguments一起使用，比如HfArgumentParser可以為TrainingArguments創建一個參數解析器，這對CLI應用程序很有用。

#TrainingArguments
 training_arguments = TrainingArguments(
     output_dir=output_dir,
     num_train_epochs=num_train_epochs,
     per_device_train_batch_size=per_device_train_batch_size,
     gradient_accumulation_steps=gradient_accumulation_steps,
     optim=optim,
     save_steps=save_steps,
     logging_steps=logging_steps,
     learning_rate=learning_rate,
     weight_decay=weight_decay,
     fp16=fp16,
     bf16=bf16,
     max_grad_norm=max_grad_norm,
     max_steps=max_steps,
     warmup_ratio=warmup_ratio,
     group_by_length=group_by_length,
     lr_scheduler_type=lr_scheduler_type,
     report_to="tensorboard"
 )

在完成微調之后，我們將使用pipeline進行推理。可以選擇各種管道任務的列表，像“圖像分類”，“文本摘要”等。還可以為任務選擇要使用的模型。為了定制也可以添加一個參數來進行某種形式的預處理，如標記化或特征提取。

pipe = pipeline(task="text-generation", model=model, tokenizer=tokenizer, max_length=200)

從transformer導入的最后一個內容是logging。這是一個日志系統，這在調試代碼時非常有用。

logging.set_verbosity(logging.CRITICAL)

從peft庫中導入的LoraConfig數據類是一個配置類，它主要存儲初始化LoraModel所需的配置，LoraModel是PeftTuner的一個實例。我們將此配置傳遞給SFTTrainer，它將使用該配置初始化適當的tuner。

# Load LoRA configuration
 peft_config = LoraConfig(
     lora_alpha=lora_alpha,
     lora_dropout=lora_dropout,
     r=lora_r,
     bias="none",
     task_type="CAUSAL_LM",
 )

PeftModel，一旦我們使用一種peft方法(如LoRA)進行微調，就需要將LoRA適配器權重保存到磁盤并在使用時將它們加載回內存。PEFT模塊微調的權重，與基本模型權重是分開。使用PeftModel，還可以選擇將將base_model權重與新微調的適配器權重合并(調整)，這樣就得到了一個完整的新模型。PeftModel.from_pretrained()從內存中加載適配器權重，merge_and_unload()方法將它們與base_model合并。

# Reload base_model in FP16 and merge it with LoRA weights
 base_model = AutoModelForCausalLM.from_pretrained(
     model_name,
     low_cpu_mem_usage=True,
     return_dict=True,
     torch_dtype=torch.float16,
     device_map=device_map,
 )
 model = PeftModel.from_pretrained(base_model, new_model)
 model = model.merge_and_unload()

最后一個導入是SFTTrainer。SFTTrainer是transformer Trainer類的子類。Trainer是一個功模型訓練的泛化API。SFTTrainer在此基礎上增加了對參數微調的支持。有監督的微調步驟是訓練因果語言模型(如Llama)用于下游任務(如指令遵循)的關鍵步驟。

SFTTrainer支持PEFT，因此我們將與LoRA一起使用SFTTrainer。然后，SFTTrainer將使用LoRA執行監督微調。然后我們可以運行訓練器(train())并保存權重(save_pretrained())。

#Initialize the SFTTrainer object
 trainer = SFTTrainer(
     model=model,
     train_dataset=dataset,
     peft_config=peft_config,
     dataset_text_field="text",
     max_seq_length=max_seq_length,
     tokenizer=tokenizer,
     args=training_arguments,
     packing=packing,
 )
 # Train model
 trainer.train()
 
 # Save trained model
 trainer.model.save_pretrained(new_model)

對于引用，我們也總結了一張圖片

訓練參數

現在我們知道了需要哪些庫來調優Llama 2(或任何LLM)，也知道了這些庫中需要的類，并且了解了這些類的功能。下面就是對前面導入的參數的介紹

模型和數據集名稱:

# The model that you want to train from the Hugging Face hub
 model_name = "NousResearch/Llama-2-7b-chat-hf"
 
 # The instruction dataset to use
 dataset_name = "mlabonne/guanaco-llama2-1k"
 
 # Fine-tuned model name
 new_model = "llama-2-7b-miniguanaco"

model_name、dataset_name和new_model。這些名稱遵循HuggingFace模型及其hub上的數據集名稱的格式。

birushuo 給一個名字“NousResearch/ Llama-2-7b-chat-hf”這個名字的第一部分NousResearch是一個研究機構，也就是它HuggingFace賬戶的名稱，第二部分是模型名稱lama-2 - 7b-chat-hf。模型命名的建議是給模型提供描述性的名稱，包括有用的信息，如獨特的模型名稱(lama-2)，關鍵參數信息(7b)，以及一些關于模型如何工作的其他有用信息(chat-hf)。我們在new_model名稱llama-2-7b-miniguanaco中看到了同樣的規則，這是我們分配給微調模型的名稱。這里附加了在miniguanaco上進行微調的數據集的名稱。

QLoRA 參數:

# LoRA attention dimension
 lora_r = 64
 
 # Alpha parameter for LoRA scaling
 lora_alpha = 16
 
 # Dropout probability for LoRA layers
 lora_dropout = 0.1

我們將使用的參數是r (lora_r)、lora_alpha和lora_dropout。這些參數對于LoRA來說是最重要的，要理解其中的原因，必須深入了解LoRA的論文，我們只做簡單的總結：

在神經網絡中，反向傳播算法計算期望值和實際值之間的誤差，然后用這個誤差來計算delta，這是神經網絡中權重對e的貢獻。如果你有一個神經網絡的初始權值W0那么對于誤差e，我們計算delta_W0 =?W。然后使用?W來更新權重W0 +?W，以減小誤差e。LoRA提出將?W分解為兩組低秩矩陣A和B，使W0 +?W = W0 + BA。而不是使用完整的?W更新，我們使用較小的低秩更新矩陣BA，這就是我們如何實現相同效率和更低的計算需求。如果?W的大小為(d × k) (W0的大小)，則我們將?W分解為兩個矩陣:B和A，維度分別為(d × r)和(r × k)，其中r為秩。

LoraConfig中的參數r (lora_r)是決定更新矩陣BA形狀的秩。根據論文可以設置一個小的秩，并且得到很好的結果。當我們更新W0時，可以通過使用縮放因子α來控制BA的影響，這個縮放因子作為學習率。比例因子是我們的第二個參數(lora_alpha)。最后設置lora_dropput，這是正則化的典型dropput。

BitsandBytes參數:

# Activate 4-bit precision base model loading
 use_4bit = True
 
 # Compute dtype for 4-bit base models
 bnb_4bit_compute_dtype = "float16"
 
 # Quantization type (fp4 or nf4)
 bnb_4bit_quant_type = "nf4"
 
 # Activate nested quantization for 4-bit base models (double quantization)
 use_nested_quant = False

我們正在使用一種稱為QLoRA的量化版本的LoRA，這意味著我們希望在LoRA微調中使用量化，將量化應用于我們前面提到的更新權重(以及其他可以量化的操作)。

參數use_4bit(第6行)設置為True，以使用高保真的4位微調，這是后來在QLoRA論文中引入的，以實現比LLM.int8論文中引入的8位量化更低的內存要求。

設置bnb_4bit_compute_dtype(第9行)，這是執行計算的數據類型(float16)。也就是說雖然將權重通過4位量化存儲，但計算還是發生在16位或32位。

使用bnb_4bit_quant_type(第12行)，nf4，根據QLoRA論文，nf4顯示了更好的理論和經驗性能。

參數use_nested_quant設置為False，并將其傳遞給bnb_4bit_use_double_quant。模型在第一次量化之后啟用第二次量化，從而為每個參數額外節省0.4位。

上面一些參數都是QLoRA的論文提供，如果想深入了解，請查看論文或我們以前的文章

在本文中我們選擇NF4量化FP16 (float16)精度進行計算后，我們應該對Colab T4 GPU (16 GB VRAM)沒有內存限制。我們做個簡單的計算：如果使用Llama-2-7B(70億params)和FP16(沒有量化)，我們得到7B × 2字節= 14 GB(所需的VRAM)。使用4位量化，我們得到7B × 0.5字節= ~ 4gb(所需的VRAM)。

訓練參數:

# Output directory where the model predictions and checkpoints will be stored
 output_dir = "./results"
 
 # Number of training epochs
 num_train_epochs = 1
 
 # Enable fp16/bf16 training (set bf16 to True with an A100)
 fp16 = False
 bf16 = False
 
 # Batch size per GPU for training
 per_device_train_batch_size = 4
 
 # Batch size per GPU for evaluation
 per_device_eval_batch_size = 4
 
 # Number of update steps to accumulate the gradients for
 gradient_accumulation_steps = 1
 
 # Maximum gradient normal (gradient clipping)
 max_grad_norm = 0.3
 
 # Initial learning rate (AdamW optimizer)
 learning_rate = 2e-4
 
 # Weight decay to apply to all layers except bias/LayerNorm weights
 weight_decay = 0.001
 
 # Optimizer to use
 optim = "paged_adamw_32bit"
 
 # Learning rate schedule (constant a bit better than cosine)
 lr_scheduler_type = "constant"
 
 # Ratio of steps for a linear warmup (from 0 to learning rate)
 warmup_ratio = 0.03
 
 # Group sequences into batches with same length
 # Saves memory and speeds up training considerably
 group_by_length = True
 
 # Save checkpoint every X updates steps
 save_steps = 25
 
 # Log every X updates steps
 logging_steps = 25

Output_dir(第6行):這是設置存儲模型預測和檢查點的位置，還包括日志

num_train_epochs(第9行):訓練的輪次

fp16和bf16(第12行和第13行):我們將它們都設置為false，因為我們不會使用混合精度訓練，因為已經有QLoRA了。

per_device_train_batch_size和per_device_eval_batch_size(第16行和第19行):將它們都設置為4。有足夠的內存，可以設置更高的批處理大小(>8)，這將加快訓練速度。

Gradient_accumulation_steps(第22行):“梯度累積”指的是在實際更新模型權重之前執行的向前和向后傳遞的次數(更新步驟)。在每一次向前和向后傳遞期間，梯度被計算并累積在一批數據上。在累積指定步數的梯度之后，然后執行反向傳遞，計算這些步驟的平均梯度并相應地更新模型權重。這種方法有助于有效地模擬更大批大小，它減少了每次向前和向后傳遞的內存需求。

max_gradient_norm(第25行):如果梯度的范數(幅度)超過某個閾值(由max_grad_norm參數指定)，則梯度裁剪縮小梯度。如果梯度范數大于max_grad_norm，則梯度將按比例縮小，如果梯度規范已經低于max_grad_norm，則不應用縮放。建議從max_grad_norm的較高值開始，然后在多個訓練迭代中慢慢縮小它。

learning_rate(第28行):AdamW的學習率。AdamW是流行的Adam優化器的一個變體。它結合了Adam優化器和權重衰減正則化的技術。

weight_decay(第31行):權重衰減，也稱為L2正則化或權重正則化，是機器學習和深度學習中常用的一種正則化技術，用于防止模型對訓練數據的過擬合。它的工作原理是在損失函數中添加一個懲罰項。我們使用AdamW和權重衰減是有意義的，因為權重衰減在微調期間特別有用，因為它有助于防止過擬合，并確保模型適應新任務，同時保留預訓練中的一些知識。

optim(第34行):使用AdamW優化器，“paged_adamw_32bit”似乎是AdamW優化器的一個特定實現或變體，我們找到任何關于他的信息，所以如果你有關于這方面的信息，請在評論中留下，謝謝!

lr_scheduler_type(第37行):通常我們在深度學習模型的訓練期間使用學習率調度器，以隨時間調整學習率。

warmup_ratio(第40行):這里我們將“warmup_ratio”設置為0.03。由于每個epoch有250個訓練步驟，熱身階段將持續到前8步(250的3%)，在此期間，學習率將從0線性增加到指定的初始值2e-4。熱身階段通常用于穩定訓練，防止梯度爆炸，并允許模型開始有效地學習。

group_by_length(第44行):這個參數設置為True，會加快了訓練速度。當group_by_length設置為True時，它將訓練數據集中大致相同長度的樣本分組到同一批中。這意味著具有相似長度的序列被分組在一起，減少了所需的填充。也就是說批將具有更相似長度的序列，這將最小化所應用的填充量。當批處理具有一致的大小時GPU處理通常更有效，從而縮短訓練時間，這是從LSTM時代就開始的一個加速技巧。

save_steps和logging_steps(第47行和第50行):這里將兩個參數都設置為25，以控制記錄訓練信息和保存檢查點的間隔步驟。

SFTTrainer參數:

max_seq_length = None
 
 # Pack multiple short examples in the same input sequence to increase efficiency
 packing = False

最后參數是特定于SFTTrainer的。

max_seq_length:將max_seq_length設置為None允許我們不施加最大序列長度限制，我們不想截斷或填充它們到固定長度，因此將max_seq_length設置為None允許我們使用數據中存在的全部序列長度。

packing:根據文檔，ConstantLengthDataset使用這個參數來打包數據集的序列。在ConstantLengthDataset上下文中將packing設置為False可以在處理多個簡短示例時提高效率，我們的數據集就是這種情況。通過將packing設置為False，允許ConstantLengthDataset將多個短示例打包到單個輸入序列中，有效地組合它們。這減少了對大量填充的需求，并提高了內存使用和計算的效率。

加載數據集、基本模型和標記器

device_map = {"": 0}
 
 # Load dataset (you can process it here)
 dataset = load_dataset(dataset_name, split="train")
 
 # Load tokenizer and model with QLoRA configuration
 compute_dtype = getattr(torch, bnb_4bit_compute_dtype)
 
 bnb_config = BitsAndBytesConfig(
     load_in_4bit=use_4bit,
     bnb_4bit_quant_type=bnb_4bit_quant_type,
     bnb_4bit_compute_dtype=compute_dtype,
     bnb_4bit_use_double_quant=use_nested_quant,
 )
 
 # Check GPU compatibility with bfloat16
 if compute_dtype == torch.float16 and use_4bit:
     major, _ = torch.cuda.get_device_capability()
     if major >= 8:
         print("=" * 80)
         print("Your GPU supports bfloat16: accelerate training with bf16=True")
         print("=" * 80)
 
 # Load base model
 model = AutoModelForCausalLM.from_pretrained(
     model_name,
     quantization_config=bnb_config,
     device_map=device_map
 )
 model.config.use_cache = False
 model.config.pretraining_tp = 1
 
 # Load LLaMA tokenizer
 tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
 tokenizer.add_special_tokens({'pad_token': '[PAD]'})
 tokenizer.pad_token = tokenizer.eos_token
 tokenizer.padding_side = "right"
 
 # Load LoRA configuration
 peft_config = LoraConfig(
     lora_alpha=lora_alpha,
     lora_dropout=lora_dropout,
     r=lora_r,
     bias="none",
     task_type="CAUSAL_LM",
 )

第5行加載數據集。然后在第9行使用gettr函數將compute_dtype設置為torch.float16。在第10行，初始化BitsandBytesConfig。

在第17行，我們使用torch.cuda.get_device_capability()函數檢查GPU與bfloat16的兼容性。該函數返回支持cuda的GPU設備的計算能力。計算能力表示GPU支持的版本和特性。該函數返回一個由兩個整數組成的元組，(major, minor)，表示GPU的主要和次要計算能力版本。主要版本表示該計算能力的主要版本，次要版本表示該計算能力的次要版本。例如，如果函數返回(8,0)，則表示GPU的計算能力為8.0版本，次要是0。如果GPU是bfloat16兼容的，那么我們將compute_dtype設置為torch.Bfloat16，因為Bfloat16比float16更好的精度

然后就是使用AutoModelForCausalLM.from_pretrained加載基本模型，在第31行設置了model.config。use_cache為False，當啟用緩存時可以減少變量。禁用緩存則在執行計算的順序方面引入了一定程度的隨機性，這在微調時非常有用。

在第32行設置了model.config.pretraining_tp = 1這里的tp代表張量并行性，根據這里的Llama 2的提示:

設置model.config. pretraining_tp = 1不等于1的值將激活更準確但更慢的線性層計算，這應該更好地匹配原始概率。

然后就是使用model_name加載Llama標記器。如果你看一下NousResearch/ lama-2的文件，你會注意到有一個tokenizer. model文件。使用model_name, AutoTokenizer可以下載該標記器。

在第36行，調用add_special_tokens({' pad_token ': ' [PAD] '})這是另一個重要代碼，因為我們數據集中的文本長度可以變化，批處理中的序列可能具有不同的長度。為了確保批處理中的所有序列具有相同的長度，需要將填充令牌添加到較短的序列中。這些填充標記通常是沒有任何含義的標記，例如。

在第37行，我們設置tokenizer. pad_token = tokenizer. eos_token。將pad令牌與EOS令牌對齊，并使我們的令牌器配置更加一致。兩個令牌(pad_token和eos_token)都有指示序列結束的作用。設置成一個簡化了標記化和填充邏輯。

在第38行，設置填充邊，將填充邊設置為右可以修復溢出問題。

最后在第41行，我們初始化了LoraConfig

訓練

# Set training parameters
 training_arguments = TrainingArguments(
     output_dir=output_dir,
     num_train_epochs=num_train_epochs,
     per_device_train_batch_size=per_device_train_batch_size,
     gradient_accumulation_steps=gradient_accumulation_steps,
     optim=optim,
     save_steps=save_steps,
     logging_steps=logging_steps,
     learning_rate=learning_rate,
     weight_decay=weight_decay,
     fp16=fp16,
     bf16=bf16,
     max_grad_norm=max_grad_norm,
     max_steps=max_steps,
     warmup_ratio=warmup_ratio,
     group_by_length=group_by_length,
     lr_scheduler_type=lr_scheduler_type,
     report_to="tensorboard"
 )
 
 # Set supervised fine-tuning parameters
 trainer = SFTTrainer(
     model=model,
     train_dataset=dataset,
     peft_config=peft_config,
     dataset_text_field="text",
     max_seq_length=max_seq_length,
     tokenizer=tokenizer,
     args=training_arguments,
     packing=packing,
 )
 
 # Train model
 trainer.train()
 
 # Save trained model
 trainer.model.save_pretrained(new_model)

在第2行使用前面詳細討論過的形參初始化TrainingArguments。然后將TrainingArguments與討論的其他相關參數一起傳遞到第30行上的SFTTrainer中。

這里新加的一個參數是第27行的dataset_text_field= " text "。dataset_text_field參數用于指示數據集中哪個字段包含作為模型輸入的文本數據。它使datasets 庫能夠基于該字段中的文本數據自動創建ConstantLengthDataset，簡化數據準備過程。

HuggingFace生態系統是一個緊密結合的庫生態系統，它在后臺為你自動化了很多工作。

推理

logging.set_verbosity(logging.CRITICAL)
 
 # Run text generation pipeline with our next model
 prompt = "What is a large language model?"
 pipe = pipeline(task="text-generation", model=model, tokenizer=tokenizer, max_length=200)
 result = pipe(f"< s >[INST] {prompt} [/INST]")
 print(result[0]['generated_text'])

第6行，管道初始化。然后在第7行使用管道，傳遞使用第5行提示符構造的輸入文本。我們使用來指示序列的開始，而添加[INST]和[/INST]作為控制令牌來指示用戶消息的開始和結束。

~## 用適配器權重重新加載基本模型

# Reload model in FP16 and merge it with LoRA weights
 base_model = AutoModelForCausalLM.from_pretrained(
     model_name,
     low_cpu_mem_usage=True,
     return_dict=True,
     torch_dtype=torch.float16,
     device_map=device_map,
 )
 model = PeftModel.from_pretrained(base_model, new_model)
 model = model.merge_and_unload()
 
 # Reload tokenizer to save it
 tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
 tokenizer.add_special_tokens({'pad_token': '[PAD]'})
 tokenizer.pad_token = tokenizer.eos_token
 tokenizer.padding_side = "right"

在第2行使用AutoModelForCausalLM.from_pretrained來(重新)加載基本模型。我們將在沒有任何量化配置的情況下執行此操作，因為我們不需要對其進行微調，只是想將其與適配器合并。還在第13行重新加載標記器，并進行與之前在第13 - 14行中所做的相同的修改。

保存

最后我們將剛剛經過微調的模型及其標記器保存到本地或者上傳到HuggingFace。

model.push_to_hub(new_model, use_temp_dir=False)
 tokenizer.push_to_hub(new_model, use_temp_dir=False)

總結

peft,tramsformers等庫簡化了我們對于大模型開發的工作流程，并且不需要很多的專業知識也可以對大模型進行微調。但是要得到一個好的模型是一個漫長的過程，就像我們上面的代碼一樣，看似簡單實則復雜，不僅要了解方法的原理，還要通過查看論文了解每一個參數的含義。

~