当前位置：首页 > news >正文

【Google Colab】利用unsloth针对医疗数据集进行大语言模型的快速微调（含跑通原代码）

news 来源：原创 2025/6/8 8:49:16

【本文概述】

为了快速跑通，首先忽略算力等问题，使用google colab云端服务器，选择unsloth/DeepSeek-R1-Distill-Llama-8B大语言模型进行微调，微调参数只进行了简单的设置。

在微调的时候，实际说明colab对8B的模型微调算力不足，故只选取了数据集中的一部分进行训练，最终的微调实现效果并不好，但的确可以看到很明显的调试效果，暂可视为本项目运行成功，后期再考虑算力、数据集、微调参数、微调模型的质量等，适合初期尝试利用unsloth进行微调理解的项目。

【准备工作】

Colab： 只需要一个 Google 账户，免费版提供 T4 GPU（约 15GB 显存），足够跑 7B 参数模型。
本地环境： 用于部署的电脑建议至少 8GB 内存（运行 7B 模型），若有 NVIDIA GPU 可加速。
网络： 稳定的互联网连接，用于下载模型和数据集

【项目流程】

【0-建立项目】

在云端硬盘中新建笔记本

更改运行时类型，选择T4 GPU后进行保存

【1-安装依赖】

在 Colab 新建笔记本，运行以下代码安装所需库：
这些库包括 Unsloth 主程序、bitsandbytes（用于量化模型）和 unsloth_zoo（预训练模型支持）。

%%capture
# 这是一个 Jupyter Notebook 的魔法命令，用于隐藏命令的输出。
# 通过捕获输出，可以让 Colab 的界面更整洁，避免显示冗长的安装日志。# 安装 unsloth 包。
# unsloth 是一个高效的工具，用于微调大型语言模型（LLM），能显著减少显存需求并加速训练。
!pip install unsloth# 卸载当前已安装的 unsloth 包（如果存在），然后从 GitHub 安装最新版本。
# "-y" 表示自动确认卸载，"--upgrade" 确保获取最新版，"--no-cache-dir" 避免使用缓存，
# "--no-deps" 跳过依赖安装（因为我们只关心 unsloth 本身），
# 通过 GitHub 源安装可以获得最新的功能和修复。
!pip uninstall unsloth -y && pip install --upgrade --no-cache-dir --no-deps git+https://github.com/unslothai/unsloth.git# 安装 bitsandbytes 和 unsloth_zoo 两个依赖包。
# bitsandbytes 是一个用于模型量化的库，支持 4 位和 8 位精度，能大幅降低内存占用。
# unsloth_zoo 提供了一些预训练模型或相关工具，方便用户快速上手。
!pip install bitsandbytes unsloth_zoo

随后在colab上配置系统环境变量，以便正确地使用CUDA。通过设置LD_LIBRARY_PATH和CUDA_HOME，它确保系统能够找到CUDA的动态链接库和安装路径，从而让依赖CUDA的程序（如深度学习框架TensorFlow、PyTorch等）能够正常运行。

import os
os.environ['LD_LIBRARY_PATH'] = '/usr/local/cuda/lib64:' + os.environ.get('LD_LIBRARY_PATH', '')
os.environ['CUDA_HOME'] = '/usr/local/cuda'

为了确保项目顺利运行，再通过pip命令安装和管理Python库。

!pip install --upgrade pip
!pip install torch
!pip install transformers
!pip install accelerate
!pip install bitsandbyte
!pip install trl

torch、torchvision、torchaudio：通过指定--extra-index-url https://download.pytorch.org/whl/cu124，安装的是与colab中CUDA 12.4兼容的版本。
transformers、accelerate、bitsandbytes、trl：安装的是这些库的最新版本（通过pip install命令默认行为）。

以下对安装的库进行简单解释

pip（升级）：

!pip install --upgrade pip：升级pip到最新版本，确保后续安装操作能够顺利进行。

torch（PyTorch）：

!pip install torch：安装PyTorch库。PyTorch是一个流行的深度学习框架，广泛用于研究和生产环境。

!pip install torchvision torchaudio：安装与PyTorch配套的torchvision（用于计算机视觉任务）和torchaudio（用于音频处理任务）库。

!pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu124：指定从PyTorch的CUDA 12.4版本的预编译包中安装PyTorch及其配套库。这通常是为了确保与特定版本的CUDA兼容。

transformers：

!pip install transformers：安装Hugging Face的transformers库。这是一个用于自然语言处理（NLP）的库，提供了预训练模型（如BERT、GPT等）的接口和工具。

accelerate：

!pip install accelerate：安装accelerate库。这是一个用于简化分布式训练和混合精度训练的库，由Hugging Face开发。

bitsandbytes：

!pip install bitsandbytes：安装bitsandbytes库。这是一个用于优化深度学习模型的库，特别是在量化和内存优化方面。

!pip uninstall bitsandbytes：卸载bitsandbytes库。可能是为了重新安装特定版本或解决冲突。

!pip install bitsandbytes：重新安装bitsandbytes库。

trl：

!pip install trl：安装trl（Transformer Reinforcement Learning）库。这是一个用于强化学习和Transformer模型结合的库。

【在安装对应库时有可能出现的问题】

在安装上述库时执行后期代码出现了版本冲突的问题，现给出执行中可能能帮助解决的方案：

bitsandbytes的卸载与重新安装：卸载了bitsandbytes，然后又重新安装了。为了解决版本冲突或确保安装的是正确的版本。
torch的卸载与重新安装：卸载了torch、torchvision和torchaudio，然后通过指定CUDA版本的URL重新安装。为了确保安装的PyTorch版本与CUDA 12.4兼容。

!pip uninstall bitsandbytes
!pip uninstall torch torchvision torchaudio
!pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu124
!pip install bitsandbytes
!pip install --upgrade torch torchvision transformers

通过再执行这些代码后后期没有出现版本冲突的报错。

【2-加载预训练模型】

首先验证unsloth是否成功安装的代码：

from unsloth import FastLanguageModel
print("Unsloth installed successfully!")

可以打印说明已经成功安装，如果无法打印则说明unsloth没有安装成功，重复上述的步骤

验证成功后，选择一个基础模型，这里用 unsloth/DeepSeek-R1-Distill-Llama-8B：

# 导入 PyTorch 库，它是深度学习的基础框架，用于处理模型的张量计算和 GPU 加速。
import torch
# 导入 Unsloth 提供的 FastLanguageModel 类，用于加载和操作高效的大型语言模型。
from unsloth import FastLanguageModel# 设置模型处理文本的最大序列长度（单位：token），这里设为 2048。
# 这决定了模型一次能处理的文本长度，越大越能捕捉长上下文，但也增加显存需求。
max_seq_length = 2048# 设置模型的数据类型（dtype），这里设为 None 表示让 Unsloth 自动选择最优类型。
# 通常会根据硬件支持选择 float16 或 bfloat16，以平衡精度和性能。
dtype = None# 启用 4 位量化加载模型，值为 True。
# 4 位量化可以将模型大小和显存需求减少约 75%，非常适合在资源有限的环境（如 Colab 免费版）运行。
load_in_4bit = True# 从预训练模型库中加载指定的模型和对应的 tokenizer（分词器）。
# 返回两个对象：model（模型本身）和 tokenizer（用于将文本转为数字输入的工具）。
model, tokenizer = FastLanguageModel.from_pretrained(model_name="unsloth/DeepSeek-R1-Distill-Llama-8B",  # 指定模型名称，这里使用 Unsloth 优化的 DeepSeek-R1-Distill-Llama-8B。max_seq_length=max_seq_length,                      # 使用上面定义的最大序列长度。dtype=dtype,                                       # 使用上面定义的数据类型（自动选择）。load_in_4bit=load_in_4bit,                         # 启用 4 位量化加载。# token="hf_...",                                  # 如果需要访问私有模型，可以取消注释并填入 Hugging Face 的 API 令牌。
)

【3-微调前测试】

先测试模型未经训练的表现：
这里调用推理模型进行推理，理想状态下，输出可能是泛泛而谈，微调后会更精准。但在本项目执行的时候微调结果不比微调前好，是因为训练集不够，暂时忽略这个问题。

# 定义提示模板（prompt_style），这是一个多行字符串，用于格式化输入和输出。
# 模板包含指令、问题和回答部分，设计目的是引导模型生成结构化的回答。
prompt_style = """以下是描述任务的指令，以及提供进一步上下文的输入。
请写出一个适当完成请求的回答。
在回答之前，请仔细思考问题，并创建一个逻辑连贯的思考过程，以确保回答准确无误。### 指令：
你是一位精通医学知识的医生，能够回答关于疾病、治疗方案和健康建议的问题。
请回答以下医疗问题。### 问题：
{}### 回答：
<think>{}"""# 定义一个测试问题，用于在微调前检查模型的初始能力。
# 这里选择了一个常见的医疗问题，方便观察模型的表现。
question = "我最近总是感到疲劳，可能是什么原因？"# 将模型切换到推理模式。
# FastLanguageModel.for_inference 是 Unsloth 提供的方法，优化模型以进行生成任务，避免训练时的额外开销。
FastLanguageModel.for_inference(model)# 使用 tokenizer 将格式化的提示转换为模型可处理的数字输入。
# prompt_style.format(question, "") 将问题插入模板，思考部分暂时为空（留给模型生成）。
# return_tensors="pt" 表示返回 PyTorch 张量格式，to("cuda") 将数据移到 GPU 上加速处理。
inputs = tokenizer([prompt_style.format(question, "")], return_tensors="pt").to("cuda")# 调用模型生成回答。
# input_ids 是编码后的输入序列，attention_mask 指示哪些部分需要关注，
# max_new_tokens=1200 限制生成最多 1200 个新 token，use_cache=True 启用缓存以加速生成。
outputs = model.generate(input_ids=inputs.input_ids,attention_mask=inputs.attention_mask,max_new_tokens=1200,use_cache=True,
)# 将模型生成的数字输出解码为人类可读的文本。
# batch_decode 处理批量输出，这里取第一个（也是唯一一个）结果。
response = tokenizer.batch_decode(outputs)# 打印生成的回答，展示模型在微调前的能力。
# response[0] 是解码后的完整文本，可能包含提示部分和生成的回答。
print(response[0])

【4-加载与格式化数据集】

使用 shibing624/medical 中文医疗数据集：
在这里定义了一个叫做 train_prompt_style 的字符串模板，给模型的一份“任务说明书”。

目的是告诉模型，它现在是一位精通医学知识的医生，需要回答医疗相关的问题。这个模板分为几个部分：首先，写一个总体的任务描述，提醒模型要认真思考并给出准确的回答；接着，明确指令，设定模型的角色和任务；然后，用 {} 留了三个占位符，分别用来填入具体的问题、思考过程和最终的回答。这样，就能确保模型在训练时按照这个结构生成内容，比如先分析问题，再给出专业建议。这样设计既清晰又有逻辑，方便模型学习如何像医生一样思考和回应。

train_prompt_style = """以下是描述任务的指令，以及提供进一步上下文的输入。
请写出一个适当完成请求的回答。
在回答之前，请仔细思考问题，并创建一个逻辑连贯的思考过程，以确保回答准确无误。### 指令：
你是一位精通医学知识的医生，能够回答关于疾病、治疗方案和健康建议的问题。
请回答以下医疗问题。### 问题：
{}### 回答：
<思考>
{}
</思考>
{}"""

在这段代码里主要是为了准备训练数据，让模型能理解和生成医疗相关的回答。

首先，定义一个结束标记EOS_TOKEN，这是从分词器里拿来的，用来告诉模型每段文本到哪里结束。接着，从 datasets 库里导入了 load_dataset 函数，用它加载了一个医疗数据集 shibing624/medical，选了finetune 配置里的前 200 条训练数据。为了搞清楚数据长什么样，打印它的字段名，结果是 instruction、input 和 output。

然后，写一个函数 formatting_prompts_func，用来把这些数据格式化成想要的样子：从数据里抽出instruction 作为问题，input 作为思考过程，output 作为回答，再用之前定义的 train_prompt_style 模板把它们组合起来，加上结束标记，最后存进一个列表里。

通过 dataset.map 方法，批量处理所有数据，最后输出第一条格式化后的文本，看看是不是按预期工作。这一步的目的是让数据变成模型能直接学习的格式，确保训练顺利进行。

# 定义结束标记（EOS_TOKEN），用于指示文本的结束
EOS_TOKEN = tokenizer.eos_token  # 必须添加结束标记# 导入数据集加载函数
from datasets import load_dataset
# 加载指定的数据集，选择中文语言和训练集的前500条记录
dataset = load_dataset("shibing624/medical", 'finetune', split = "train[0:200]", trust_remote_code=True)
# 打印数据集的列名，查看数据集中有哪些字段
print(dataset.column_names)

格式化数据集中的记录，并且进行打印查看

# 定义一个函数，用于格式化数据集中的每条记录
def formatting_prompts_func(examples):# 从数据集中提取问题、复杂思考过程和回答inputs = examples["instruction"]cots = examples["input"]outputs = examples["output"]texts = []  # 用于存储格式化后的文本# 遍历每个问题、思考过程和回答，进行格式化for input, cot, output in zip(inputs, cots, outputs):# 使用字符串模板插入数据，并加上结束标记text = train_prompt_style.format(input, cot, output) + EOS_TOKENtexts.append(text)  # 将格式化后的文本添加到列表中return {"text": texts,  # 返回包含所有格式化文本的字典}dataset = dataset.map(formatting_prompts_func, batched = True)
dataset["text"][0]

【5-执行微调训练】

配置 LoRA 并开始训练：
训练约需实践视数据量而定。

# 将模型切换到训练模式。
# FastLanguageModel.for_training 是 Unsloth 提供的方法，确保模型准备好进行参数更新，而不是仅用于推理。
FastLanguageModel.for_training(model)# 配置并返回一个支持参数高效微调（PEFT）的模型。
# get_peft_model 使用 LoRA 技术，只更新模型的部分参数，从而减少显存需求和计算开销。
model = FastLanguageModel.get_peft_model(model,  # 传入之前加载的预训练模型，作为微调的基础。r=16,   # 设置 LoRA 的秩（rank），控制新增可训练参数的规模。值越大，模型调整能力越强，但显存需求也增加。target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],# 指定需要应用 LoRA 的模型模块，这些是 Transformer 架构中的关键部分（如注意力机制和前馈网络）。lora_alpha=16,# LoRA 的缩放因子，影响新增参数对模型的贡献程度。通常与 r 成比例设置，这里为 16。lora_dropout=0,# 设置 LoRA 层的 dropout 比率，用于防止过拟合。这里设为 0，表示不丢弃任何参数。bias="none",# 指定是否为 LoRA 参数添加偏置项。"none" 表示不添加，保持轻量化。use_gradient_checkpointing="unsloth",# 启用梯度检查点技术，Unsloth 优化版本能节省显存，支持更大的批量大小或模型。random_state=3407,# 设置随机种子，确保每次运行时模型初始化的随机性一致，便于结果复现。use_rslora=False,# 是否使用 Rank-Stabilized LoRA（一种改进的 LoRA 变体）。这里设为 False，使用标准 LoRA。loftq_config=None,# 设置是否使用 LoftQ（一种量化技术）。这里设为 None，表示不启用。
)

80次的训练步数完成后，unsloth会给出模型训练中的关键信息：

TrainOutput(global_step=80, training_loss=0.4147318692877889, metrics={'train_runtime': 862.1409, 'train_samples_per_second': 0.742, 'train_steps_per_second': 0.093, 'total_flos': 1.1264877371523072e+16, 'train_loss': 0.4147318692877889})

即：

训练进度：已经完成了80个训练步骤。
训练性能：平均损失值为0.4147，训练过程耗时约862秒。
效率指标：每秒处理约0.742个样本，每秒完成约0.093个训练步骤，总共执行了约1.13×10¹⁶次浮点运算。

# 导入 SFTTrainer 类，用于监督微调训练。
# SFTTrainer 是 TRL（Transformers Reinforcement Learning）库提供的工具，适合基于指令的数据集微调模型。
from trl import SFTTrainer# 导入 TrainingArguments 类，用于定义训练的超参数。
# 这是 Hugging Face Transformers 库的核心类，允许灵活配置训练过程。
from transformers import TrainingArguments# 导入 Unsloth 提供的函数，用于检查硬件是否支持 bfloat16 数据类型。
# bfloat16 是一种高效的半精度格式，能在支持的硬件上加速训练。
from unsloth import is_bfloat16_supported# 创建 SFTTrainer 实例，配置训练所需的模型、数据和参数。
trainer = SFTTrainer(model=model,                    # 传入之前配置好的模型（已启用 LoRA）。tokenizer=tokenizer,                # 传入与模型配套的分词器，用于处理文本数据。train_dataset=dataset,               # 传入训练数据集（已格式化为包含 "text" 字段）。dataset_text_field="text",             # 指定数据集中包含训练文本的字段名，这里是 "text"。max_seq_length=max_seq_length,           # 设置最大序列长度，与模型加载时保持一致（如 2048）。dataset_num_proc=2,                # 设置数据处理的并行进程数，加速数据预处理。packing=False,                   # 是否启用序列打包。False 表示不打包，每条数据独立处理。args=TrainingArguments(              # 定义训练超参数的配置对象。per_device_train_batch_size=2,       # 每个设备（GPU）的批次大小，设为 2 以适应显存限制。gradient_accumulation_steps=4,       # 梯度累积步数，累积 4 次小批次后更新参数，模拟大批量训练。warmup_steps=5,              # 预热步数，学习率在前 5 步逐渐增加，稳定训练。max_steps=80,               # 最大训练步数，控制训练时长（步数 = 数据量 / 批次大小）。learning_rate=2e-4,            # 学习率，设为 0.0002，控制参数更新速度。fp16=not is_bfloat16_supported(),    # 如果不支持 bfloat16，则使用 fp16（16 位浮点数）加速训练。bf16=is_bfloat16_supported(),       # 如果硬件支持 bfloat16，则启用它，兼顾精度和速度。logging_steps=1,              # 每 1 步记录一次训练日志，方便监控损失变化。optim="adamw_8bit",            # 使用 8 位 AdamW 优化器，节省显存并保持性能。weight_decay=0.01,             # 权重衰减系数，设为 0.01，防止模型过拟合。lr_scheduler_type="linear",        # 学习率调度器类型，"linear" 表示线性衰减。seed=3407,                 # 随机种子，确保训练结果可复现。output_dir="outputs",            # 训练结果（如检查点）保存的目录。report_to="none",              # 不将训练日志报告到外部工具（如 WandB），仅本地记录。),
)# 开始训练模型。
# trainer.train() 执行微调过程，根据配置更新模型参数，完成后保存到 output_dir。
trainer.train()

【6-微调后测试】

用相同问题测试效果：
理想状态下，回答更贴近医疗专业知识。

给出的回复是：

我最近总是感到疲劳，可能是什么原因？ <｜begin▁of▁sentence｜>以下是描述任务的指令，以及提供进一步上下文的输入。请写出一个适当完成请求的回答。在回答之前，请仔细思考问题，并创建一个逻辑连贯的思考过程，以确保回答准确无误。 ### 指令：你是一位精通医学知识的医生，能够回答关于疾病、治疗方案和健康建议的问题。请回答以下医疗问题。 ### 问题：我最近总是感到疲劳，可能是什么原因？ ### 回答： <think>스테因素不足引起的疲劳感多为神经因素性疲劳，主要表现为全身肌肉无力、四肢乏力、深度脑性疲劳、脑力劳动者、长期性肥胖、糖尿病、2型糖尿病、胰岛 B 细胞突变导致的糖尿病也可以引起的疲劳感。多发于中青年群体，少见于老年群体。<｜end▁of▁sentence｜>

print(question) # 打印前面的问题
# 将模型切换到推理模式，准备回答问题
FastLanguageModel.for_inference(model)# 将问题转换成模型能理解的格式，并发送到 GPU 上
inputs = tokenizer([prompt_style.format(question, "")], return_tensors="pt").to("cuda")# 让模型根据问题生成回答，最多生成 4000 个新词
outputs = model.generate(input_ids=inputs.input_ids,       # 输入的数字序列attention_mask=inputs.attention_mask,  # 注意力遮罩，帮助模型理解哪些部分重要max_new_tokens=4000,          # 最多生成 4000 个新词use_cache=True,            # 使用缓存加速生成
)# 将生成的回答从数字转换回文字
response = tokenizer.batch_decode(outputs)# 打印回答
print(response[0])

到此，微调项目执行完成。

当前因为训练的数据集很少，最后输出的回答效果并不好，后期需要加大数据量等。

理想状态下，最终的输出模式应该是如下图所示：

【7-导出微调后的模型-可选】

将微调后的模型保存为 GGUF 格式

GGUF，全称是 GPT-Generated Unified Format（GPT 生成的统一格式），是一种专门为存储和部署大型语言模型（LLM）设计的文件格式。简单来说，它就像一个“打包盒”，把模型的所有必要信息都装在一起，比如模型的权重（参数）、分词器（tokenizer）信息、超参数（hyperparameters）和元数据（metadata），全都压缩成一个二进制文件。这样做的好处是方便高效地加载和运行模型，尤其是在本地设备上。

执行前我们需要先在Colab中配置token的环境变量

# 导入 Google Colab 的 userdata 模块，用于访问用户数据
from google.colab import userdata# 从 Google Colab 用户数据中获取 Hugging Face 的 API 令牌
HUGGINGFACE_TOKEN = userdata.get('HUGGINGFACE_TOKEN')# 将模型保存为 8 位量化格式（Q8_0）
# 这种格式文件小且运行快，适合部署到资源受限的设备
if True: model.save_pretrained_gguf("model", tokenizer,)# 将模型保存为 16 位量化格式（f16）
# 16 位量化精度更高，但文件稍大
if False: model.save_pretrained_gguf("model_f16", tokenizer, quantization_method = "f16")# 将模型保存为 4 位量化格式（q4_k_m）
# 4 位量化文件最小，但精度可能稍低
if False: model.save_pretrained_gguf("model", tokenizer, quantization_method = "q4_k_m")

配置HUGGINGFACE_TOKEN的环境变量

首先我们先获取到Huggingface的token

将微调后的模型上传到 HuggingFace

# 导入 Hugging Face Hub 的 create_repo 函数，用于创建一个新的模型仓库
from huggingface_hub import create_repo# 在 Hugging Face Hub 上创建一个新的模型仓库
create_repo("xiongwenhao/medical_finetuned", token=HUGGINGFACE_TOKEN, exist_ok=True)# 将模型和分词器上传到 Hugging Face Hub 上的仓库
model.push_to_hub_gguf("xiongwenhao/medical_finetuned", tokenizer, token=HUGGINGFACE_TOKEN)

使用Ollama运行微调后的模型

ollama run hf.co/{用户名}/{上传到HuggingFace的模型名称}
示例：ollama run hf.co/xiongwenhao/medical_finetuned

注：本人在第7步保存和导出模型没有测试成功，参考项目见“参考资料”中的地址，本文在这一步仅作为存档，以免后续需要使用时原帖失效。

【参考资料】

[1] 轻松微调大模型：利用 Colab 和 Unsloth 实现高效训练：https://blog.csdn.net/weixin_66401877/article/details/145892615