適用于各種NLP任務的開源LLM的finetune教程~

ChatGLM2-6b是清華開源的小尺寸LLM，只需要一塊普通的顯卡(32G較穩妥)即可推理和微調，是目前社區非?；钴S的一個開源LLM。

本范例使用非常簡單的，外賣評論數據集來實施微調，讓ChatGLM2-6b來對一段外賣評論區分是好評還是差評。

可以發現，經過微調后的模型，相比直接 3-shot-prompt 可以取得明顯更好的效果。

值得注意的是，盡管我們以文本分類任務為例，實際上，任何NLP任務，例如，命名實體識別，翻譯，聊天對話等等，都可以通過加上合適的上下文，轉換成一個對話問題，并針對我們的使用場景，設計出合適的數據集來微調開源LLM.

〇，預訓練模型

國內可能速度會比較慢，總共有14多個G，網速不太好的話，大概可能需要一兩個小時。

如果網絡不穩定，也可以手動從這個頁面一個一個下載全部文件然后放置到 一個文件夾中例如 'chatglm2-6b' 以便讀取。

fromtransformersimportAutoModel,AutoTokenizer
model_name="chatglm2-6b"#或者遠程“THUDM/chatglm2-6b”
tokenizer=AutoTokenizer.from_pretrained(
model_name,trust_remote_code=True)
model=AutoModel.from_pretrained(model_name,trust_remote_code=True).half().cuda()

Loading checkpoint shards:   0%|          | 0/7 [00:00
prompt="""文本分類任務：將一段用戶給外賣服務的評論進行分類，分成好評或者差評。

下面是一些范例:

味道真不錯->好評
太辣了，吃不下都->差評

請對下述評論進行分類。返回'好評'或者'差評'，無需其它說明和解釋。

xxxxxx->

"""

defget_prompt(text):
returnprompt.replace('xxxxxx',text)


response,his=model.chat(tokenizer,get_prompt('味道不錯，下次還來'),history=[])
print(response)

好評

#增加4個范例
his.append(("太貴了->","差評"))
his.append(("非?？?，味道好->","好評"))

his.append(("這么咸真的是醉了->","差評"))
his.append(("價格感人優惠多多->","好評"))


	

	我們來測試一下

	
response,history=model.chat(tokenizer,"一言難盡啊->",history=his)
print(response)

response,history=model.chat(tokenizer,"還湊合一般般->",history=his)
print(response)

response,history=model.chat(tokenizer,"我家狗狗愛吃的->",history=his)
print(response)


差評
差評
好評

#封裝成一個函數吧~
defpredict(text):
response,history=model.chat(tokenizer,f"{text}->",history=his,
temperature=0.01)
returnresponse

predict('死鬼，咋弄得這么有滋味呢')#在我們精心設計的一個評論下，ChatGLM2-6b終于預測錯誤了~

'差評'


	

	我們拿外賣數據集測試一下未經微調，純粹的 6-shot prompt 的準確率。

	
importpandasaspd
importnumpyasnp
importdatasets


df=pd.read_csv("data/waimai_10k.csv")

df['tag']=df['label'].map({0:'差評',1:'好評'})
df=df.rename({'review':'text'},axis=1)

dfgood=df.query('tag=="好評"')
dfbad=df.query('tag=="差評"').head(len(dfgood))#采樣部分差評，讓好評差評平衡
df=pd.concat([dfgood,dfbad])


print(df['tag'].value_counts())


好評    4000
差評    4000

ds_dic=datasets.Dataset.from_pandas(df).train_test_split(
test_size=2000,shuffle=True,seed=43)
dftrain=ds_dic['train'].to_pandas()
dftest=ds_dic['test'].to_pandas()
dftrain.to_parquet('data/dftrain.parquet')
dftest.to_parquet('data/dftest.parquet')


preds=[''forxindftest['tag']]

fromtqdmimporttqdm
foriintqdm(range(len(dftest))):
text=dftest['text'].loc[i]
preds[i]=predict(text)

dftest['pred']=preds

dftest.pivot_table(index='tag',columns='pred',values='text',aggfunc='count')


	

	

	
acc=len(dftest.query('tag==pred'))/len(dftest)

print('acc=',acc)

acc= 0.878


	

	可以看到，微調之前，我們的模型準確率為87.8%，下面我們通過6000條左右數據的微調，看看能否把acc打上去~ 

	一，準備數據

	我們需要把數據整理成對話的形式，即 context 和 target 的配對，然后拼到一起作為一條樣本。

	ChatGLM模型本質上做的是一個文字接龍的游戲，即給定一段話的上半部分，它會去續寫下半部分。

	我們這里指定上半部分為我們設計的文本分類任務的prompt，下半部分為文本分類結果。

	所以我們微調的目標就是讓它預測的下半部分跟我們的設定的文本分類一致。

	1，數據加載

	
importpandasaspd
importnumpyasnp
importdatasets

dftrain=pd.read_parquet('data/dftrain.parquet')
dftest=pd.read_parquet('data/dftest.parquet')


dftrain['tag'].value_counts()

好評    3006
差評    2994
Name: tag, dtype: int64

#將上下文整理成與推理時候一致，參照model.chat中的源碼~
#model.build_inputs??
defbuild_inputs(query,history):
prompt=""
fori,(old_query,response)inenumerate(history):
prompt+="[Round {}]

問：{}

答：{}

".format(i+1,old_query,response)
prompt+="[Round {}]

問：{}->

答：".format(len(history)+1,query)
returnprompt

print(build_inputs('味道不太行',history=his))


[Round 1]

問：文本分類任務：將一段用戶給外賣服務的評論進行分類，分成好評或者差評。

下面是一些范例:

味道真不錯 -> 好評
太辣了，吃不下都  -> 差評

請對下述評論進行分類。返回'好評'或者'差評'，無需其它說明和解釋。

味道不錯，下次還來 ->



答：好評

[Round 2]

問：太貴了 -> 

答：差評

[Round 3]

問：非?？?，味道好 -> 

答：好評

[Round 4]

問：這么咸真的是醉了 -> 

答：差評

[Round 5]

問：價格感人 優惠多多 -> 

答：好評

[Round 6]

問：味道不太行 -> 

答：

dftrain['context']=[build_inputs(x,history=his)forxindftrain['text']]
dftrain['target']=[xforxindftrain['tag']]
dftrain=dftrain[['context','target']]

dftest['context']=[build_inputs(x,history=his)forxindftest['text']]
dftest['target']=[xforxindftest['tag']]
dftest=dftest[['context','target']]

dftest

ds_train=datasets.Dataset.from_pandas(dftrain)
ds_val=datasets.Dataset.from_pandas(dftest)



	

	2，token編碼

	為了將文本數據喂入模型，需要將詞轉換為token。

	也就是把context轉化成context_ids，把target轉化成target_ids.

	同時，我們還需要將context_ids和target_ids拼接到一起作為模型的input_ids。

	這是為什么呢？

	因為ChatGLM2基座模型是一個TransformerDecoder結構，是一個被預選練過的純粹的語言模型(LLM，Large Lauguage Model)。

	一個純粹的語言模型，本質上只能做一件事情，那就是計算任意一段話像'人話'的概率。

	我們將context和target拼接到一起作為input_ids， ChatGLM2 就可以判斷這段對話像'人類對話'的概率。

	在訓練的時候我們使用梯度下降的方法來讓ChatGLM2的判斷更加準確。

	訓練完成之后，在預測的時候，我們就可以利用貪心搜索或者束搜索的方法按照最像"人類對話"的方式進行更合理的文本生成。

	
fromtqdmimporttqdm
importtransformers

model_name="chatglm2-6b"
max_seq_length=512
skip_over_length=True

tokenizer=transformers.AutoTokenizer.from_pretrained(
model_name,trust_remote_code=True)

config=transformers.AutoConfig.from_pretrained(
model_name,trust_remote_code=True,device_map='auto')

defpreprocess(example):
context=example["context"]
target=example["target"]

context_ids=tokenizer.encode(
context,
max_length=max_seq_length,
truncation=True)

target_ids=tokenizer.encode(
target,
max_length=max_seq_length,
truncation=True,
add_special_tokens=False)

input_ids=context_ids+target_ids+[config.eos_token_id]

return{"input_ids":input_ids,"context_len":len(context_ids),'target_len':len(target_ids)}


ds_train_token=ds_train.map(preprocess).select_columns(['input_ids','context_len','target_len'])
ifskip_over_length:
ds_train_token=ds_train_token.filter(
lambdaexample:example["context_len"]
ds_val_token=ds_val.map(preprocess).select_columns(['input_ids','context_len','target_len'])
ifskip_over_length:
ds_val_token=ds_val_token.filter(
lambdaexample:example["context_len"]

	

	3, 管道構建

	
defdata_collator(features:list):
len_ids=[len(feature["input_ids"])forfeatureinfeatures]
longest=max(len_ids)#之后按照batch中最長的input_ids進行padding

input_ids=[]
labels_list=[]

forlength,featureinsorted(zip(len_ids,features),key=lambdax:-x[0]):
ids=feature["input_ids"]
context_len=feature["context_len"]

labels=(
[-100]*(context_len-1)+ids[(context_len-1):]+[-100]*(longest-length)
)#-100標志位后面會在計算loss時會被忽略不貢獻損失，我們集中優化target部分生成的loss

ids=ids+[tokenizer.pad_token_id]*(longest-length)

input_ids.append(torch.LongTensor(ids))
labels_list.append(torch.LongTensor(labels))


input_ids=torch.stack(input_ids)
labels=torch.stack(labels_list)
return{
"input_ids":input_ids,
"labels":labels,
}


importtorch
dl_train=torch.utils.data.DataLoader(ds_train_token,num_workers=2,batch_size=4,
pin_memory=True,shuffle=True,
collate_fn=data_collator)
dl_val=torch.utils.data.DataLoader(ds_val_token,num_workers=2,batch_size=4,
pin_memory=True,shuffle=True,
collate_fn=data_collator)


forbatchindl_train:
break


dl_train.size=300#每300個step視作一個epoch，做一次驗證


	

	二，定義模型

	
importwarnings
warnings.filterwarnings("ignore")


fromtransformersimportAutoTokenizer,AutoModel,TrainingArguments,AutoConfig
importtorch
importtorch.nnasnn
frompeftimportget_peft_model,LoraConfig,TaskType

model=AutoModel.from_pretrained("chatglm2-6b",
load_in_8bit=False,
trust_remote_code=True,
device_map='auto')

model.supports_gradient_checkpointing=True#節約cuda
model.gradient_checkpointing_enable()
model.enable_input_require_grads()
#model.lm_head=CastOutputToFloat(model.lm_head)

model.config.use_cache=False#silencethewarnings.Pleasere-enableforinference!


peft_config=LoraConfig(
task_type=TaskType.CAUSAL_LM,inference_mode=False,
r=8,
lora_alpha=32,lora_dropout=0.1,
)

model=get_peft_model(model,peft_config)
model.is_parallelizable=True
model.model_parallel=True
model.print_trainable_parameters()



	

	

	可以看到，通過使用LoRA微調方法，待訓練參數只有全部參數的3%左右。

	三，訓練模型

	我們使用我們的夢中情爐torchkeras來實現最優雅的訓練循環~

	注意這里，為了更加高效地保存和加載參數，我們覆蓋了KerasModel中的load_ckpt和save_ckpt方法，

	僅僅保存和加載lora權重，這樣可以避免加載和保存全部模型權重造成的存儲問題。

	
fromtorchkerasimportKerasModel
fromaccelerateimportAccelerator

classStepRunner:
def__init__(self,net,loss_fn,accelerator=None,stage="train",metrics_dict=None,
optimizer=None,lr_scheduler=None
):
self.net,self.loss_fn,self.metrics_dict,self.stage=net,loss_fn,metrics_dict,stage
self.optimizer,self.lr_scheduler=optimizer,lr_scheduler
self.accelerator=acceleratorifacceleratorisnotNoneelseAccelerator()
ifself.stage=='train':
self.net.train()
else:
self.net.eval()

def__call__(self,batch):

#loss
withself.accelerator.autocast():
loss=self.net(input_ids=batch["input_ids"],labels=batch["labels"]).loss

#backward()
ifself.optimizerisnotNoneandself.stage=="train":
self.accelerator.backward(loss)
ifself.accelerator.sync_gradients:
self.accelerator.clip_grad_norm_(self.net.parameters(),1.0)
self.optimizer.step()
ifself.lr_schedulerisnotNone:
self.lr_scheduler.step()
self.optimizer.zero_grad()

all_loss=self.accelerator.gather(loss).sum()

#losses(orplainmetricsthatcanbeaveraged)
step_losses={self.stage+"_loss":all_loss.item()}

#metrics(statefulmetrics)
step_metrics={}

ifself.stage=="train":
ifself.optimizerisnotNone:
step_metrics['lr']=self.optimizer.state_dict()['param_groups'][0]['lr']
else:
step_metrics['lr']=0.0
returnstep_losses,step_metrics

KerasModel.StepRunner=StepRunner


#僅僅保存lora可訓練參數
defsave_ckpt(self,ckpt_path='checkpoint.pt',accelerator=None):
unwrap_net=accelerator.unwrap_model(self.net)
unwrap_net.save_pretrained(ckpt_path)

defload_ckpt(self,ckpt_path='checkpoint.pt'):
self.net=self.net.from_pretrained(self.net,ckpt_path)
self.from_scratch=False

KerasModel.save_ckpt=save_ckpt
KerasModel.load_ckpt=load_ckpt


keras_model=KerasModel(model,loss_fn=None,
optimizer=torch.optim.AdamW(model.parameters(),lr=2e-6))
ckpt_path='waimai_chatglm4'


keras_model.fit(train_data=dl_train,
val_data=dl_val,
epochs=100,patience=5,
monitor='val_loss',mode='min',
ckpt_path=ckpt_path,
mixed_precision='fp16'
)



	

	

	曲線下降非常優美~

	四，驗證模型

	
frompeftimportPeftModel
model=AutoModel.from_pretrained("chatglm2-6b",
load_in_8bit=False,
trust_remote_code=True,
device_map='auto')
model=PeftModel.from_pretrained(model,ckpt_path)
model=model.merge_and_unload()#合并lora權重


defpredict(text):
response,history=model.chat(tokenizer,f"{text}->",history=his,
temperature=0.01)
returnresponse

predict('死鬼，咋弄得這么有滋味呢')


'差評'

dftest=pd.read_parquet('data/dftest.parquet')

preds=[''forxindftest['text']]

fromtqdmimporttqdm
foriintqdm(range(len(dftest))):
text=dftest['text'].loc[i]
preds[i]=predict(text)

100%|██████████| 2000/2000 [03:39<00:00,  9.11it/s]

dftest['pred']=preds

dftest.pivot_table(index='tag',columns='pred',values='text',aggfunc='count')


	

	
acc=len(dftest.query('tag==pred'))/len(dftest)
print('acc=',acc)


	

	acc= 0.903

	還行，用6000條數據，訓練了一個小時左右，準確率到了90.3%，比未經微調的prompt方案的87.8%相比漲了兩個多點~

	五，使用模型

	我們可以調整溫度temperature參數，看看有沒有機會把這個評論

	'死鬼，咋弄得這么有滋味呢' 預測正確

	
defpredict(text,temperature=0.8):
response,history=model.chat(tokenizer,f"{text}->",history=his,
temperature=temperature)
returnresponse

foriinrange(10):
print(predict('死鬼，咋弄得這么有滋味呢'))

差評
好評
好評
好評
差評
差評
好評
差評
差評
好評


	

	可以看到，這個評論模型其實是不太吃得準它是好評還是差評的，畢竟，死鬼這個詞的內涵太豐富了，跟字面的意思并不一樣

	我們測試一下模型的其他場景對話能力是否受到影響？

	
response,history=model.chat(tokenizer,"跑步比賽如果你超過了第二名，你會成為第幾名？",history=[])
print(response)

如果在跑步比賽中超過了第二名,那么現在就是第二名。如果想要知道現在排名第幾,需要知道自己和其他人的成績。如果知道了所有人的成績,就可以計算出自己在所有選手中的排名。


	

	六，保存模型

	可以將模型和tokenizer都保存到一個新的路徑，便于直接加載。

	
model.save_pretrained("chatglm2-6b-waimai",max_shard_size='1GB')

tokenizer.save_pretrained("chatglm2-6b-waimai")

('chatglm2-6b-waimai/tokenizer_config.json',
 'chatglm2-6b-waimai/special_tokens_map.json',
 'chatglm2-6b-waimai/tokenizer.model',
 'chatglm2-6b-waimai/added_tokens.json')


	

	還需要將相關的py文件也復制過去。

	
!lschatglm2-6b



	

	

	
!cpchatglm2-6b/*.pychatglm2-6b-waimai/

!lschatglm2-6b-waimai



	

	

	
fromtransformersimportAutoModel,AutoTokenizer
model_name="chatglm2-6b-waimai"
tokenizer=AutoTokenizer.from_pretrained(
model_name,trust_remote_code=True)
model=AutoModel.from_pretrained(model_name,
trust_remote_code=True).half().cuda()

prompt="""文本分類任務：將一段用戶給外賣服務的評論進行分類，分成好評或者差評。

下面是一些范例:

味道真不錯->好評
太辣了，吃不下都->差評

請對下述評論進行分類。返回'好評'或者'差評'，無需其它說明和解釋。

xxxxxx->

"""

defget_prompt(text):
returnprompt.replace('xxxxxx',text)


response,his=model.chat(tokenizer,get_prompt('狗子，怎么做的這么好吃呀？'),history=[])
print(response)

好評


	

	收工。

	

	




	審核編輯：劉清