微调

{
    "input(instruction)":"根据给定的描述,生成一个创意的营销文案旨在吸引年轻人购买最新款智能手机。描述:这款手机拥有超强的摄像头和全天候的电池续航,适合喜欢拍照和玩游戏的年轻人。",
    "output":"探索无限可能!这款全新智能手机,不仅拥有顶级摄像头记录每个瞬间,还有持久电力陪伴你畅玩每一刻。立即拥有,让生活更精彩!"
}

import json
from transformers import AutoTokenizer

# 模型路径
model_path = './model/Qwen2.5-0.5B-Instruct'
tokenizer = AutoTokenizer.from_pretrained(model_path)
print('tokenizer加载完成')

print('一个单轮对话样例测试')

data = {
  "instruction": "将以下英文翻译成中文。\nHello, how are you?",
  "input": "",
  "output": "你好，你好吗？"
}
messages = [
    {"role": "user", "content": data['instruction']},
    {"role": "assistant", "content": data['output']}
]

chat_template = tokenizer.apply_chat_template(
    messages, 
    add_generation_prompt= False, # 加上当前模型的对话模板
    tokenize=False # 是否要转成token id
)

print('转换后的数据：\n{}'.format(chat_template))
转换后的数据：
<|im_start|>system
You are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>
<|im_start|>user
将以下英文翻译成中文。
Hello, how are you?<|im_end|>
<|im_start|>assistant
你好，你好吗？<|im_end|>

import json
import random
random.seed(42)
# 处理医疗诊断数据集

# 输出的数据集名称
dataset_name = 'dialog'
# 在下载后的文件夹内
read_file = './dataset/Chinese-medical-dialogue/data/train_0001_of_0001.json'
with open(read_file, 'r') as f:
    datas = json.load(f)

# 原始的数据格式为json
# instruction：主题
# input：内容
# output：医生的回复
# history：都为空
'''
{'instruction': '孕妇感冒发烧38度应该怎么办呢',
 'input': '我怀孕了我的身体最近变得很差，现在我总是感冒发烧非常的严重。最近一次发烧38度，我感觉头非常的疼痛又不敢打针吃药，现在非常得难受痛苦.想得到怎样的帮助：孕妇感冒发烧38度应该怎办的呢？',
 'output': '孕妇发烧时，要寻出发烧的病因，对症下药，若是一般由感冒引来的发烧，不论对妈妈或胎儿而言，预后应该是很好的。孕妇若必须动用药物，必须考量药物对胎儿健康的干扰，因此必须与妇产科医师充分谈论后再动用。可以物理降温，把毛巾放到装温水的盆中，然后把水拧出，全身擦试，特别是额头、手臂弯，大腿根部，手脚心处擦试，这样效果会很好的，要多喝生姜和大枣熬的热水，然后消肿。以上是对“孕妇感冒发烧38度应当怎办的呢？”这个问题的建议，期望对您有协助，祝您健康！',
 'history': None
}
'''

# 只选取5100条
# 5000条训练
# 100条测试
random.shuffle(datas) # 全部数据打乱一下，要不然取到的数据症状都是类似的
datas = datas[:5000] # 共选取5000条
processed_datas = []
for data in datas:
    # 将主题和内容拼接起来
    inp = '主题：{}\n内容：{}'.format(data['instruction'], data['input'])
    # 组成指令数据
    processed_data = {
        'instruction': inp,
        'input':'',
        'output': data['output']
    }
    processed_datas.append(processed_data)

print('全部数据量:{}'.format(len(processed_datas)))

# 输出指令数据
with jsonlines.open(os.path.join(output_dir, '{}_train.jsonl'.format(dataset_name)), 'w') as f:
    for data in processed_datas:
        f.write(data)
        
# 求一下最大长度（后面微调的时候设置参数需要用到）
max_len = 0
for data in processed_datas:
    now_len = len(tokenizer(data['instruction']+'\n'+data['output'])['input_ids'])
    if now_len > max_len:
        max_len = now_len
print('最大长度为:{}'.format(max_len))

import pandas as pd
read_files = [
'./dataset/yidu-n7k/train.xlsx',
'./dataset/yidu-n7k/val.xlsx'
]

out_types = [
    'train',
    'test'
]

# 原始的数据格式为excel
'''
|原始词|标准词|
|---|---|
|右侧甲状腺叶切除术|单侧甲状腺叶切除术|
'''
# 第1列为原始词
# 第2列为标准化词

pd.read_excel('./dataset/yidu-n7k/train.xlsx')

dataset_name = 'norm'
# 由于没有任务说明，我们需要自己来为这个任务写一个任务描述的prompt
prompt = '''你是一个医疗专家，你的任务是临床术语标准化。
具体来说，针对给出的通用语，转换为相应的标准化医学术语，确保转换后的内容符合医学专业标准，直接输出转换后的临床标准术语。
原始词：{word}
该词的标准术语为：'''

for read_file, out_type in zip(read_files, out_types):
    processed_datas = []
    # 使用pandas加载数据
    datas = pd.read_excel(read_file)
    
    for i in range(datas.shape[0]):
        before_word = datas.iloc[i,0]
        after_word = datas.iloc[i,1]

        instruction = prompt.format(word = before_word)
        output = after_word

        # 构造指令数据
        processed_data = {
            'instruction': instruction,
            'input': '',
            'output': output
        }
        processed_datas.append(processed_data)

    # 训练集选取5000条
    if out_type == 'train':
        processed_datas = processed_datas[:5000]
    else:
    # 测试集选取100条
        processed_datas = processed_datas[:100]
    with jsonlines.open(os.path.join(output_dir, '{}_{}.jsonl'.format(dataset_name, out_type)), 'w') as f:
        for data in processed_datas:
            f.write(data)
            
max_len = 0
for read_file, out_type in zip(read_files, out_types):
    with jsonlines.open(os.path.join(output_dir, '{}_{}.jsonl'.format(dataset_name, out_type)), 'r') as f:
        processed_datas = [data for data in f]
        # 求一下最大长度
        for data in processed_datas:
            now_len = len(tokenizer(data['instruction']+'\n'+data['output'])['input_ids'])
            if now_len > max_len:
                max_len = now_len
print('最大长度为:{}'.format(max_len))

# 加载微调所需要的包
import os
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
import json
from transformers import (
    AutoTokenizer, 
    AutoModelForCausalLM, 
    Seq2SeqTrainer, 
    Seq2SeqTrainingArguments, 
    DataCollatorForSeq2Seq
)
from datasets import Dataset
import torch
import jsonlines

# 先加载模型和分词器
model_path = './model/Qwen2.5-0.5B-Instruct'
tokenizer = AutoTokenizer.from_pretrained(model_path, padding_side = 'left')
model = AutoModelForCausalLM.from_pretrained(model_path, torch_dtype = torch.bfloat16, device_map = 'auto')

# 加载所有处理后的数据集
data_files = [
    './dataset/sft_dataset/dialog_train.jsonl',
    './dataset/sft_dataset/norm_train.jsonl',
    './dataset/sft_dataset/mrg_train.jsonl',
]
all_datas = []
for data_file in data_files:
    print('加载数据集:{}'.format(data_file))
    with jsonlines.open(data_file, 'r') as f:
        datas = [data for data in f]
    print(len(datas))
    all_datas.extend(datas)
print('全部数据数量:{}'.format(len(all_datas)))

def preprocess_example(example):
    """
    利用 tokenizer.apply_chat_template 构造 prompt_text 和 full_text：
    整条数据为 instruction + output，
    然后将 prompt 部分的 label 置为 -100，这样只用剩余的output部分计算损失。
    """

    # 先计算prompt部分的长度
    messages = [
        {'role':'user', 'content': example['instruction']}
    ]
    prompt_ids = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize = True
    )
    
    # 求出全部数据
    messages = [
        {'role':'user', 'content': example['instruction']},
        {'role':'assistant', 'content': example['output']},
    ]

    label_ids = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=False,
        tokenize = True
    )

    prompt_length = len(prompt_ids)
    input_ids = label_ids.copy()
    label_ids[:prompt_length] = [-100] * prompt_length # 即， 告诉模型："这部分不用学习"
    tokenized = {}
    tokenized["input_ids"] = input_ids
    tokenized["labels"] = label_ids
    return tokenized

# 将数据转换为 HuggingFace datasets 格式
dataset = Dataset.from_list(all_datas)
# 调用上面定义的预处理函数，移除原始字段
processed_dataset = dataset.map(preprocess_example, remove_columns=list(dataset[0].keys()))

print("处理完成。")


# 数据整理器（Data Collator）（自动处理不同长度的文本）
data_collator = DataCollatorForSeq2Seq(tokenizer, model=model)

# 配置训练参数(重点讲)
training_args = Seq2SeqTrainingArguments(
    output_dir=None,                       
    save_strategy = 'no',                 # 不保存中间结果
    num_train_epochs=2.0,                 # 学习数据的遍数，根据实际情况调整
    per_device_train_batch_size=1,        # 每个设备每次处理的数据量
    gradient_accumulation_steps=8,        # 累计8次再更新
    learning_rate = 1e-4, #5e-5~1e-4      # 学习速度
    logging_steps=100,                    # 每 100 步记录一次日志
    # warmup_steps=50,                    # 预热 warmup
    # save_steps=500,                     # 每 500 步保存模型
    bf16=True,                            # 使用省内存的浮点数格式，若使用支持fp16的GPU，可启用
)

# 构建一个训练器 Seq2SeqTrainer
trainer = Seq2SeqTrainer(
    model=model,                        # 接受训练的学生
    args=training_args,                 # 训练时的参数
    train_dataset=processed_dataset,    # 课本
    data_collator=data_collator,        # 活页夹
    tokenizer=tokenizer,                # 字典
)

# 开始训练
trainer.train()

# 训练结束后保存最终模型
trainer.save_model("./model/finetune/Qwen2.5-0.5B_med_2")

import os
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
from transformers import AutoModelForCausalLM,AutoTokenizer
import json
import jsonlines
import torch
from tqdm import tqdm
model_path_1 = '/ai/deployment/20250417/model/Qwen2.5-0.5B-Instruct'
model_path_2 = '/ai/deployment/20250417/model/finetune/Qwen2.5-0.5B_med_1'

# 每个模型的tokenizer都是一样的
tokenizer = AutoTokenizer.from_pretrained(model_path_1, padding_side = 'left')
model_1 = AutoModelForCausalLM.from_pretrained(model_path_1, torch_dtype = torch.bfloat16, device_map = 'auto')
model_2 = AutoModelForCausalLM.from_pretrained(model_path_2, torch_dtype = torch.bfloat16, device_map = 'auto')
assert tokenizer.padding_side == 'left'
print('模型加载完成')

def get_output(datas, tokenizer, model, batch_size=16,max_new_tokens=2000):
    """
    对输入数据分批处理，生成输出文本

    参数:
    - datas: 一个字符串列表，每个字符串为一个输入句子或文本。
    - tokenizer: 使用的分词器，用于将文本转换为模型输入。
    - model: 用于生成文本的模型。
    - batch_size: 每个批次处理的样本数，默认为4。

    返回:
    - outputs: 包含生成文本的列表。
    """
    outputs = []
    # 按批次处理数据
    for i in tqdm(range(0, len(datas), batch_size)):
        batch_data = datas[i:i + batch_size]
        # 将批次数据编码成模型输入，并移动到模型设备上
        inputs = tokenizer(batch_data, return_tensors="pt", padding=True, truncation=True).to(model.device)
        # 使用模型生成新的文本，限制生成的 token 数量
        output_sequences = model.generate(**inputs, max_new_tokens=max_new_tokens)
        processed_output_sequences = [output_sequences[j][len(inputs[j]):] for j in range(len(output_sequences))]
        # 解码生成的 token，去掉特殊符号
        batch_outputs = tokenizer.batch_decode(processed_output_sequences, skip_special_tokens=True)
        outputs.extend(batch_outputs)
    return outputs
    
# 术语标准化评估
test_file = '/ai/deployment/20250417/dataset/sft_dataset/norm_test.jsonl'
with jsonlines.open(test_file, 'r') as f:
    test_datas = [data for data in f]
    
inputs = []
for data in test_datas:
    messages = [{'role': 'user', 'content': data['instruction']}]
    processed_input_text = tokenizer.apply_chat_template(
        messages, 
        add_generation_prompt= True, # 加上当前模型的对话模板
        tokenize=False # 是否要转成token id
    )
    inputs.append(processed_input_text)
    
    
outputs_model_1 = get_output(inputs, tokenizer, model_1, batch_size=16, max_new_tokens = 100)
outputs_model_2 = get_output(inputs, tokenizer, model_2, batch_size=16, max_new_tokens = 100)

corr_1 = 0
corr_2 = 0
for output_model_1,test_data in zip(outputs_model_1, test_datas):
    if output_model_1 == test_data['output']:
        corr_1 += 1
for output_model_2,test_data in zip(outputs_model_2, test_datas):
    if output_model_2 == test_data['output']:
        corr_2 += 1
print('Accuracy')
print('微调前:{}%'.format(round(corr_1/len(test_datas)*100,2)))
print('微调后:{}%'.format(round(corr_2/len(test_datas)*100,2)))
import re
# 病例报告生成评估
test_file = '/ai/deployment/20250417/dataset/sft_dataset/mrg_test.jsonl'
with jsonlines.open(test_file, 'r') as f:
    test_datas = [data for data in f]
inputs = []
for data in test_datas:
    messages = [{'role': 'user', 'content': data['instruction']}]
    processed_input_text = tokenizer.apply_chat_template(
        messages, 
        add_generation_prompt= True, # 加上当前模型的对话模板
        tokenize=False # 是否要转成token id
    )
    inputs.append(processed_input_text)
outputs_model_1 = get_output(inputs, tokenizer, model_1, batch_size=16, max_new_tokens = 2000)
outputs_model_2 = get_output(inputs, tokenizer, model_2, batch_size=16, max_new_tokens = 2000)

for index,(data, model_1_result, model_2_result) in enumerate(zip(test_datas, outputs_model_1, outputs_model_2)):
    print('||输入:||{}'.format(data['instruction']))
    print('||原始模型输出:||\n{}'.format(model_1_result))
    print('||微调后模型输出:||\n{}'.format(model_2_result))
    print('----------------------------------------------------')
    if index==2:
        break
        
pred_extract = re.compile(r'```json(.*?)```', flags=re.DOTALL)

keys = [
'主诉',
'现病史',
'辅助检查',
'既往史',
'诊断',
'建议',
]

all_golds_1 = []
all_preds_1 = []

all_golds_2 = []
all_preds_2 = []
for output_model_1,test_data in zip(outputs_model_1, test_datas):
    gold_json = json.loads(test_data['output'])  # 标准答案
    try:
        if '```' in output_model_1:
            output_model_1 = pred_extract.findall(output_model_1)[0]
            pred_json = json.loads(output_model_1)
        else:
            pred_json = json.loads(output_model_1)   # 模型1的答案
    except:
        pred_json = {}
    for key in keys:  # 保存一下
        all_golds_1.append(gold_json[key])
        all_preds_1.append(str(pred_json.get(key, "")))

for output_model_2,test_data in zip(outputs_model_2, test_datas):
    gold_json = json.loads(test_data['output'])
    try:
        pred_json = json.loads(output_model_2)
    except:
        pred_json = {}
    for key in keys:
        all_golds_2.append(gold_json[key])
        all_preds_2.append(str(pred_json.get(key, "")))

corr_1 = 0
corr_2 = 0
for pred,gold in zip(all_preds_1, all_golds_1):
    if pred.strip() == gold.strip():
        corr_1 += 1
        
for pred,gold in zip(all_preds_2, all_golds_2):
    if pred.strip() == gold.strip():
        corr_2 += 1
print('Accuracy')
print('微调前:{}%'.format(round(corr_1/len(all_golds_1)*100,2)))
print('微调后:{}%'.format(round(corr_2/len(all_golds_2)*100,2)))


# 语义相似度评估
P, R, F1 = score(all_preds_1, all_golds_1, model_type='bert-base-chinese',lang="zh", verbose=True)
print('微调前')
print("BERTScore Precision: {}".format(round(P.mean().item()*100,2)))
print("BERTScore Recall: {}".format(round(R.mean().item()*100,2)))
print("BERTScore F1: {}".format(round(F1.mean().item()*100,2)))

P, R, F1 = score(all_preds_2, all_golds_2, model_type='bert-base-chinese',lang="zh", verbose=True)

print('微调后')
print("BERTScore Precision: {}".format(round(P.mean().item()*100,2)))
print("BERTScore Recall: {}".format(round(R.mean().item()*100,2)))
print("BERTScore F1: {}".format(round(F1.mean().item()*100,2)))

import BitsAndBytesConfig
import torch

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,
    torch_dtype="auto",
    device_map="auto",
    quantization_config=bnb_config
)




#################################

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
import torch

model_name = "/ai/data/DeepSeek-R1-Distill-Qwen-1.5B"

use_4bit = True
bnb_4bit_compute_dtype = "float16"
bnb_4bit_quant_type = "nf4"
use_nested_quant = False
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,
)

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype="auto",
    device_map="auto",
    quantization_config=bnb_config
)
tokenizer = AutoTokenizer.from_pretrained(model_name)

history, response = [], ""

query = input("请输入内容：")
messages = [{"role": "system", "content": "你是一个智能助手，擅长用中文回答用户的提问。"}]
while query:
    for query_h, response_h in history:
        messages.append({"role": "user", "content": query_h})
        messages.append({"role": "assistant", "content": response_h})
    messages.append({"role": "user", "content": query})

    text = tokenizer.apply_chat_template(
        messages,
        tokenize=False,
        add_generation_prompt=True
    )
    model_inputs = tokenizer([text], return_tensors="pt").to(model.device)

    generated_ids = model.generate(
        **model_inputs,
        max_new_tokens=1024,
        temperature = 0.7,
        top_p = 0.8,
        repetition_penalty=1.1
    )
    generated_ids = [
        output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
    ]

    response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
    print(response)
    history.append([query, response])
    query = input("请输入内容：")