Panda个人博客-微调Qwen大模型---医学知识问答

### 1.首先搭建Python环境
 python安装环境，需要先安装好conda，通过conda创建好一个基本的运行环境。

使用conda创建一个**qwen-ft**环境。
```bash
# python 使用python10版本，也可以是3.9
conda create -n qwen-ft python=3.10 -y
```

安装好以后，通过 conda activate qwen-ft 激活环境。
接下来需要安装PyTorch，这个需要根据自己显卡的CUDA版本去装对应的Pytorch版本，建议在Pytorch官网去找。
![图片描述](https://img.panda0101.site/article/content/1767952654503_zreblbez73.png)

cuda版本查看命令：`nvidia-smi`，由于我的cuda版本是13.0，下面是对应的Pytorch和训练所需要的依赖包的安装命令。
``` bash
pip3 install torch torchvision --index-url https://download.pytorch.org/whl/cu130
# 这是训练模型的框架
pip install transformers accelerate peft bitsandbytes datasets trl sentencepiece
# 安装ModelScope，可以通过这个下载所需要的模型权重。
pip install modelscope
```

成果安装好Pytorch后，可以通过以下代码验证CUDA是否可用
```python
import torch  
  
print("PyTorch 版本:", torch.__version__)  
print("CUDA 可用:", torch.cuda.is_available())  
print("CUDA 版本 (PyTorch 编译时):", torch.version.cuda)  
print("显存总量:", torch.cuda.get_device_properties(0).total_memory / 1e9, "GB")

# PyTorch 版本: 2.9.1+cu130
# CUDA 可用: True
# CUDA 版本 (PyTorch 编译时): 13.0
# 显存总量: 8.585216 GB

```

当torch.cuda.is_available()返回的True，则表示成功了！

### 2.下载Qwen2.5-0.5B模型
由于显卡的显存有限，只能使用0.5B模型。
通过下面的代码可以从魔塔下载相应的模型权重，下载模型是需要点时间的。
```python
from modelscope import snapshot_download  
# 从魔搭下载 Qwen2.5-0.5B-Instruct 到本地目录  
model_dir = snapshot_download(  
    'qwen/Qwen2.5-0.5B-Instruct',  
    revision='master',  # 默认分支  
    cache_dir='./models'  # 本地保存路径  
)
```

### 3.准备数据集
可以在魔塔社区 https://modelscope.cn/datasets 找到你所需要的数据集，我使用的是 `LL1112/urology_medicineQA` 医学对话数据集，可以在该网站上搜索下载该数据集。

![图片描述](https://img.panda0101.site/article/content/1767952681444_oegtj5hjyna.png)
上图是数据集的一个预览，可以看到是由问题、上下文、回答、疾病和建议字段组成。

### 4.开始微调

```python
import json  
import torch  
from datasets import Dataset  
from modelscope import AutoTokenizer, AutoModelForCausalLM  
from peft import LoraConfig, get_peft_model  
from transformers import TrainingArguments, Trainer   
SYSTEM_PROMPT = "你是一名专业医生，请根据患者的症状、检查结果和医学知识，给出诊断和治疗建议。"

# 指定模型路径  
model_path = "./models/qwen/Qwen2___5-0___5B-Instruct"  
# 数据集路径  
TRAIN_DATASET_PATH = "dataset/chat_train.json"  
OUTPUT_DIR = "./models/qwen2_5_med_lora"  
  
# 加载 tokenizertokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)  
tokenizer.pad_token = tokenizer.eos_token  
# 加载模型  
model = AutoModelForCausalLM.from_pretrained(  
    model_path,  
    device_map="auto",  
    trust_remote_code=True,  
    dtype=torch.float16,  
)  
  
# 3. 构建 LoRA 配置 (),通过LoRA方法进行微调。
peft_config = LoraConfig(  
    r=8,  
    lora_alpha=16,  
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],  
    lora_dropout=0.05,  
    bias="none",  
    task_type="CAUSAL_LM"  
)  
# 获取模型 
model = get_peft_model(model, peft_config)  
  
# 4. 加载并预处理数据集  
def load_and_process_data(file_path, system_prompt=SYSTEM_PROMPT):  
    """  
    加载原始数据集，返回包含instruction、input、output的字典列表  
    """    
		data = []  
    with open(file_path, "r", encoding="utf-8") as f:  
        for line_num, line in enumerate(f, 1):  
            line = line.strip()  
            if not line:  
                continue  
            try:  
                # 转换成json格式  
                line = json.loads(line)  
                message = {  
                    "instruction": system_prompt,  
                    "input": line['question'],  
                    "output": line['answer'],  
                }  
                # 添加到data列表中  
                data.append(message)  
            except json.JSONDecodeError as err:  
                print(f"第 {line_num} 行 JSON 解析失败: {line[:50]}... -> {err}")  
                raise  
  
    return data  
  
def process_func(example):  
    """  
    将单个样本转换为模型训练所需的格式  
    构建完整的对话，并创建对应的labels（只有assistant回答部分参与loss计算）  
    """    
		MAX_LENGTH = 2048  
    messages = [  
        {"role": "system", "content": example['instruction']},  
        {"role": "user", "content": example['input']}  
    ]  
  
    # 构建完整的对话文本（不包含assistant之后的回答）  
    instruction = tokenizer.apply_chat_template(  
        messages,  
        tokenize=False,  
        add_generation_prompt=True  
    )  
  	# instruction 这是通过 tokenizer.apply_chat_template()方法后进行处理后的模板
    """ 
        <|im_start|>system        
				你是一名专业医生，请根据患者的症状、检查结果和医学知识，给出诊断和治疗建议。<|im_end|>  
        <|im_start|>user        
				医生您好，我是60岁男性，2天前出现右侧腰痛，尿量减少来就医。到了医院急诊检查CT：双侧侧输尿管上段结石伴积水。血指标：白细胞 15.6，中性粒细胞百分比 83%，血红蛋白 127，血小板 251，C反应蛋白 91，静脉血气PH7.28，血钠 138, 血钾 4.6, AB 21，乳酸 0.8，血肌酐 865，降钙素原 0.245。请问我是什么诊断，该如何治疗？<|im_end|>  
        <|im_start|>assistant    
				"""  
  
    # 对instruction进行向量化  
    instruction_tokenized = tokenizer(instruction, add_special_tokens=False)  
  
    # 构建assistant 
    assistant_text = f"\n{example['output']}<|im_end|>"  
		# 对assistant_text内容进行向量化
    assistant_tokenized = tokenizer(assistant_text, add_special_tokens=False)  
  
    # 合并输入和输出  
    input_ids = instruction_tokenized["input_ids"] + assistant_tokenized["input_ids"]  
    # 创建attention_mask（全1，表示所有token都有效）  
    attention_mask = instruction_tokenized['attention_mask']+assistant_tokenized['attention_mask']  
    # 创建labels：instruction部分设为-100（不参与loss的计算，用户部分内容只是模型参与理解的，而模型回答的内容是需要进行学习的），assistant部分保持原值  
    instruction_len = len(instruction_tokenized["input_ids"])  
    labels = [-100] * instruction_len + assistant_tokenized["input_ids"]  
  
    # 超出截断  
    if len(input_ids) > MAX_LENGTH:  
        input_ids = input_ids[:MAX_LENGTH]  
        attention_mask = attention_mask[:MAX_LENGTH]  
        labels = labels[:MAX_LENGTH]  
    return {  
        "input_ids": input_ids,  
        "attention_mask": attention_mask,  
        "labels": labels  
    }  
  
# 加载训练集和验证集  
print(" 加载数据集...")  
train_raw_data = load_and_process_data(TRAIN_DATASET_PATH)  
train_dataset = Dataset.from_list(train_raw_data)  
  
# 使用datasets的map函数进行tokenization处理  
print("\n 处理训练集...")  
tokenized_train_dataset = train_dataset.map(  
    process_func,  
    remove_columns=train_dataset.column_names,  # 移除原始列  
    desc="Tokenizing train dataset"  
)

# 显示处理后的样本示例  
print("\n处理后示例:")  
sample = tokenized_train_dataset[0]  
print(f"input_ids长度: {len(sample['input_ids'])}")  
print(f"labels长度: {len(sample['labels'])}")  
print(f"attention_mask长度: {len(sample['attention_mask'])}")  
print(f"非-100的labels数量: {sum(1 for x in sample['labels'] if x != -100)}")  
  
# 5. 训练配置  
training_args = TrainingArguments(  
    output_dir=OUTPUT_DIR,  
    per_device_train_batch_size=2,          # 根据显存调整（8G 可设为 1～2）  
    gradient_accumulation_steps=4,          # 模拟更大 batch    
		num_train_epochs=3,  
    learning_rate=2e-4,  
    lr_scheduler_type="cosine",  
    warmup_ratio=0.1,  
    fp16=True,  
    logging_steps=5,  
    report_to="none",  
    optim="paged_adamw_8bit",               # 更省内存的优化器  
    ddp_find_unused_parameters=False,  
)  
  
  
# 6. 自定义数据整理器（确保批次内序列长度一致）  
class CustomDataCollator:  
    def __init__(self, tokenizer, max_length=2048, pad_to_multiple_of=8):  
        self.tokenizer = tokenizer  
        self.max_length = max_length  
        self.pad_to_multiple_of = pad_to_multiple_of  
  
    def __call__(self, features):  
        # 获取batch中最大的长度  
        max_len_in_batch = max(len(feature['input_ids']) for feature in features)  
  
        # 如果最大长度超过max_length，截断  
        if max_len_in_batch > self.max_length:  
            max_len_in_batch = self.max_length  
  
        # 计算padding长度（8的倍数）  
        if self.pad_to_multiple_of is not None:  
            max_len_in_batch = ((max_len_in_batch + self.pad_to_multiple_of - 1) // self.pad_to_multiple_of) * self.pad_to_multiple_of  
  
        batch = {}  
  
        for key in features[0].keys():  
            if key in ['input_ids', 'attention_mask', 'labels']:  
                # 对每个特征进行padding  
                padded_values = []  
                for feature in features:  
                    value = feature[key]  
                    # 截断到max_length  
                    if len(value) > self.max_length:  
                        value = value[:self.max_length]  
  
                    # padding到batch最大长度  
                    if len(value) < max_len_in_batch:  
                        if key == 'labels':  
                            # labels的padding使用-100  
                            pad_value = -100  
                        else:  
                            # input_ids和attention_mask的padding使用tokenizer的pad_token_id或0  
                            pad_value = self.tokenizer.pad_token_id if key == 'input_ids' and self.tokenizer.pad_token_id is not None else 0  
  
                        value.extend([pad_value] * (max_len_in_batch - len(value)))  
  
                    padded_values.append(value)  
  
                batch[key] = torch.tensor(padded_values, dtype=torch.long)  
  
        return batch  
  
data_collator = CustomDataCollator(  
    tokenizer=tokenizer,  
    max_length=2048,  
    pad_to_multiple_of=8  
)  
  
# 7. 创建Trainer  
trainer = Trainer(  
    model=model,  
    args=training_args,  
    train_dataset=tokenized_train_dataset,  
    tokenizer=tokenizer,  
    data_collator=data_collator
)  
  
# 8. 开始训练  
print(" 开始 LoRA 微调...")  
print(f" 训练配置: {training_args.num_train_epochs} epochs, batch_size={training_args.per_device_train_batch_size}")  
trainer.train()

# 9. 保存最终模型  
model.save_pretrained(OUTPUT_DIR)  
tokenizer.save_pretrained(OUTPUT_DIR)  
print(f" LoRA 适配器已保存至: {OUTPUT_DIR}")  
print(" 训练完成！最佳模型已基于验证损失自动选择并保存。")

```
### 5.测试微调后的模型效果
```python
import torch  
from modelscope import AutoTokenizer, AutoModelForCausalLM  
from peft import PeftModel  
  
# 配置路径  
BASE_MODEL_PATH = "./models/qwen/Qwen2___5-0___5B-Instruct"  
LORA_ADAPTER_PATH = "./models/qwen2_5_med_lora/checkpoint-642"  
SYSTEM_PROMPT = "你是一名专业医生，请根据患者的症状、检查结果和医学知识，给出诊断和治疗建议。"  
USER_PROMPT = """  
医生您好，我母亲57岁，3周前做了输尿管镜碎石术，手术后出现脑梗，经神经内科治疗后好转了，昨天因为一直头痛不能缓
解去看了急诊，  
留院观察，查了CT，见右侧D-J管在位，右肾周血肿较2022-11-1有增大，医生说绝对卧床+腹带加压包扎，2天后又查了CT
肾周血肿较之前无明显增大，  
神经内科医生说恢复口服阿司匹林+波立维，但是肌酐一直在升高，做了CT和之前比较考虑尿潴留导致急性肾功能不全，  
肌酐408，C反应蛋白 19.51，白细胞 9.03，中性百分比 60.9%，血红蛋白 86，血小板 250，降钙素原 0.3，D二聚体 0.92，B型钠尿肽：655 ，  
目前我母亲胃口不好，精神还行，请问我母亲现在怎么治疗才能快点好起来？  
"""

""" 这是测试集中USER_PROMPT对应的回答内容模板

您好，根据您的症状描述，你母亲输尿管结石术后，目前留置输尿管支架在位，目前主要问题就是神经源性膀胱导致的急性
尿潴留，引起肾盂压力增大，并发肾周血肿、急性肾功能不全、急性肾盂肾炎、心功能不全。应该尽快留置导尿，降低膀胱
压力，予抗感染，补充血容量或输血治疗，监测生命体征及感染指标、血红蛋白、肌酐、心功能的表现，复查膀胱残余尿B
超，观察尿量情况。

"""

def predict1():  
  
    # 加载基础模型  
    base_model = AutoModelForCausalLM.from_pretrained(  
        BASE_MODEL_PATH,  
        dtype="auto",  
        device_map="auto"  
    )  
  
    # 加载 LoRA 微调后的模型  
    model = PeftModel.from_pretrained(base_model, LORA_ADAPTER_PATH)  
    tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL_PATH)  
    messages = [  
        {"role": "system", "content": SYSTEM_PROMPT},  
        {"role": "user", "content": USER_PROMPT}  
    ]  
    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=2048  
    )  
    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)  
  
  
def predict2():  
  
    # 加载基础模型  
    model = AutoModelForCausalLM.from_pretrained(  
        BASE_MODEL_PATH,  
        dtype="auto",  
        device_map="auto"  
    )  
  
    tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL_PATH)  
    messages = [  
        {"role": "system", "content": SYSTEM_PROMPT},  
        {"role": "user", "content": USER_PROMPT}  
    ]  
    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=2048  
    )  
    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)  
  
if __name__ == "__main__":  
    print("====================================\n")  
    print("微调后的结果模型回答结果：\n")  
    predict1()  
    print("====================================\n")  
    print("没有微调后的结果模型回答结果：\n")  
    predict2()  
    print("====================================\n")
```
测试结果如下图，可以看到微调后的模型的回答就会更接近所训练的数据集中的内容。
![图片描述](https://img.panda0101.site/article/content/1767954480812_goy4uzp5e7s.png)

微调Qwen大模型---医学知识问答

如何在 Spring 启动过程中实现缓存预热？有哪些实现方式？

什么是 Spring 的三级缓存？它是如何解决循环依赖的？

Spring 的 AOP 是什么？它是如何实现的？

Mysql多表查询

Mysql的隔离级别