AI 大模型单机单卡微调-Unsloth 实战

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# 1. 卸载旧驱动（避免版本冲突）
sudo apt purge nvidia-*
sudo apt autoremove

# 2. 添加NVIDIA官方驱动源
sudo add-apt-repository ppa:graphics-drivers/ppa
sudo apt update

# 3. 查看推荐驱动版本（需≥535.xx，确保兼容CUDA 11.8）
ubuntu-drivers devices
# 输出示例：recommended: nvidia-driver-550-server（选择推荐版本）

# 4. 安装推荐驱动
sudo apt install nvidia-driver-550-server

# 5. 重启系统生效
sudo reboot

# 6. 验证驱动安装（显示GPU型号、驱动版本、CUDA版本）
nvidia-smi
# 预期输出：Driver Version: 550.xx，CUDA Version: 12.4（仅显示，非实际安装）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# 1. 下载CUDA 11.8安装脚本
wget https://developer.download.nvidia.com/compute/cuda/11.8.0/local_installers/cuda_11.8.0_520.61.05_linux.run

# 2. 赋予脚本执行权限
chmod +x cuda_11.8.0_520.61.05_linux.run

# 3. 安装CUDA Toolkit（仅安装工具包，不重复安装驱动）
sudo ./cuda_11.8.0_520.61.05_linux.run --toolkit --override

# 4. 配置CUDA环境变量（写入.bashrc实现持久化）
echo 'export PATH=/usr/local/cuda-11.8/bin:$PATH' >> ~/.bashrc
echo 'export LD_LIBRARY_PATH=/usr/local/cuda-11.8/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc
source ~/.bashrc

# 5. 验证CUDA安装（显示版本11.8）
nvcc -V
# 预期输出：release 11.8, V11.8.89

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 1. 管理员身份打开PowerShell，启用WSL2
wsl --install
# 安装完成后重启电脑

# 2. 安装Ubuntu 22.04子系统
wsl --install -d Ubuntu-22.04
# 首次启动设置Ubuntu用户名和密码

# 3. 进入WSL2环境（后续操作同Ubuntu系统）
wsl

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 1. 安装virtualenv（Ubuntu/WSL/Windows通用）
pip install virtualenv

# 2. 创建虚拟环境（命名为unsloth-env，指定Python 3.10）
virtualenv unsloth-env -p python3.10
# 注：Unsloth推荐Python 3.10，Ubuntu需提前安装：sudo apt install python3.10 python3.10-venv

# 3. 激活虚拟环境
# Ubuntu/WSL
source unsloth-env/bin/activate
# Windows CMD
unsloth-env\Scripts\activate.bat
# Windows PowerShell
.\unsloth-env\Scripts\Activate.ps1
# 激活后终端前缀显示：(unsloth-env)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 1. 创建依赖清单文件（requirements.txt）
cat > requirements.txt << EOF
unsloth==2024.5
transformers==4.41.2
peft==0.11.1
accelerate==0.30.1
bitsandbytes==0.43.0
datasets==2.19.1
tokenizers==0.19.1
torch==2.2.2+cu118
torchvision==0.17.2+cu118
torchaudio==2.2.2+cu118
wandb==0.16.6
tensorboard==2.16.2
jsonlines==4.0.0
sentencepiece==0.2.0
EOF

# 2. 安装依赖（指定CUDA 11.8版本的PyTorch）
pip install -r requirements.txt --extra-index-url https://download.pytorch.org/whl/cu118

# 3. 验证依赖安装
# 检查Unsloth版本
python -c "import unsloth; print(f'Unsloth version: {unsloth.__version__}')"
# 检查PyTorch与CUDA关联（需显示True和11.8）
python -c "import torch; print(f'Torch version: {torch.__version__}'); print(f'Torch CUDA available: {torch.cuda.is_available()}'); print(f'Torch CUDA version: {torch.version.cuda}')"

1
2
3

dataset/
├── train.json  # 训练集（建议≥100条样本，保证微调效果）
└── test.json   # 测试集（约为训练集规模的20%，用于验证）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

[
  {
    "conversations": [
      {"role": "system", "content": "你是专业医疗问答助手，回答需基于医学常识，避免误导用户"},
      {"role": "user", "content": "糖尿病患者可以吃水果吗？"},
      {"role": "assistant", "content": "糖尿病患者可以适量吃水果，但需注意以下几点：1. 选择低GI（血糖生成指数）水果，如苹果、梨、柚子、草莓等，避免高GI水果如西瓜、荔枝、榴莲；2. 控制食用量，每天建议200-300克，分次食用，避免一次性大量摄入；3. 食用时间选择两餐之间（如上午10点、下午3点），避免餐后立即食用，防止血糖叠加升高；4. 食用水果后需监测血糖，根据自身血糖变化调整种类和量；5. 若血糖控制不佳（空腹血糖>8mmol/L或餐后2小时血糖>11.1mmol/L），建议暂时避免食用水果，优先控制血糖。"}
    ]
  },
  {
    "conversations": [
      {"role": "system", "content": "你是专业医疗问答助手，回答需基于医学常识，避免误导用户"},
      {"role": "user", "content": "感冒时应该多喝水吗？"},
      {"role": "assistant", "content": "感冒时建议适量多喝水，原因如下：1. 补充水分：感冒常伴随发热、出汗，多喝水可补充身体流失的水分，防止脱水；2. 稀释痰液：有助于稀释呼吸道内的痰液，促进痰液排出，缓解咳嗽、鼻塞等症状；3. 调节体温：通过出汗散热，帮助降低体温；4. 促进代谢：加速身体新陈代谢，帮助排出体内毒素和病毒。但需注意：1. 饮水量适中，一般成年人每天1500-2000毫升即可，避免过量饮水增加肾脏负担；2. 特殊人群如心肾功能不全者，需根据医生建议控制饮水量；3. 可选择温开水、淡盐水或蜂蜜水（1岁以下婴儿禁用），避免饮用含糖量高的饮料。"}
    ]
  }
]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

from datasets import Dataset
import jsonlines
import json

def load_local_json_dataset(train_path, test_path):
    """加载本地JSON数据集并清洗格式错误样本"""
    # 读取训练集
    train_data = []
    with jsonlines.open(train_path, mode='r') as reader:
        for obj in reader:
            train_data.append(obj)
    # 读取测试集
    test_data = []
    with jsonlines.open(test_path, mode='r') as reader:
        for obj in reader:
            test_data.append(obj)
    
    # 数据清洗：过滤缺少关键角色（system/user/assistant）或空内容的样本
    def clean_data(raw_data):
        cleaned = []
        for item in raw_data:
            conv = item.get("conversations", [])
            roles = [turn.get("role") for turn in conv]
            # 检查是否包含所有关键角色
            if {"system", "user", "assistant"}.issubset(set(roles)):
                # 检查所有content非空
                if all(turn.get("content", "").strip() != "" for turn in conv):
                    cleaned.append({"conversations": conv})
        return cleaned
    
    cleaned_train = clean_data(train_data)
    cleaned_test = clean_data(test_data)
    
    # 转换为datasets.Dataset格式（便于后续处理）
    train_dataset = Dataset.from_list(cleaned_train)
    test_dataset = Dataset.from_list(cleaned_test)
    
    return {"train": train_dataset, "test": test_dataset}

# 加载数据集（替换为实际路径）
dataset = load_local_json_dataset(
    train_path="./dataset/train.json",
    test_path="./dataset/test.json"
)

# 验证加载结果
print(f"训练集样本数量：{len(dataset['train'])}")
print(f"测试集样本数量：{len(dataset['test'])}")
print(f"训练集第一条样本：\n{json.dumps(dataset['train'][0], indent=2, ensure_ascii=False)}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

from unsloth.dataprep.synthetic import prepare_qa_generation
from unsloth.chat_templates import apply_chat_template

# 从企业文档生成QA样本（支持TXT/PDF格式）
dataset = prepare_qa_generation(
    output_folder="company_kb_dataset",  # 输出目录
    max_generation_tokens=512,           # 单条回答最大长度
    temperature=0.7,                     # 生成随机性（0-1）
    overlap=64,                          # 文档片段重叠度（避免信息丢失）
    default_num_pairs=25,                # 每个文档生成25组QA
    cleanup_threshold=0.85               # 过滤低质量样本（0-1）
)

# 应用ChatML模板统一格式
dataset = apply_chat_template(
    dataset,
    tokenizer=tokenizer,  # 后续加载的模型Tokenizer
    chat_template="chatml",
    default_system_message="你是公司内部知识库助手，仅回答与公司业务相关的问题"
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# Ubuntu/WSL：设置缓存路径（替换为实际路径）
export TRANSFORMERS_CACHE="/home/your_username/.cache/huggingface/hub"
# 持久化配置（写入.bashrc）
echo "export TRANSFORMERS_CACHE=$TRANSFORMERS_CACHE" >> ~/.bashrc
source ~/.bashrc

# Windows CMD：设置缓存路径（替换为实际路径）
set TRANSFORMERS_CACHE=D:\huggingface_cache
# 持久化配置（管理员身份）
setx TRANSFORMERS_CACHE "%TRANSFORMERS_CACHE%" /M

# Windows PowerShell：设置缓存路径
$env:TRANSFORMERS_CACHE="D:\huggingface_cache"
# 持久化配置
[Environment]::SetEnvironmentVariable("TRANSFORMERS_CACHE", "D:\huggingface_cache", "Machine")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

from unsloth import FastLanguageModel
from transformers import AutoTokenizer
import os

# 选择模型（以Llama 3.2-1B为例，24GB显存可支持）
model_name = "meta-llama/Llama-3.2-1B-Instruct"

# 1. 下载Tokenizer
tokenizer = AutoTokenizer.from_pretrained(model_name)
# 保存Tokenizer到本地（可选）
tokenizer.save_pretrained("./llama-3.2-1b-tokenizer")
print(f"Tokenizer保存路径：./llama-3.2-1b-tokenizer")

# 2. 下载模型权重（加载到CPU，不占用GPU显存）
model = FastLanguageModel.from_pretrained(
    model_name=model_name,
    max_seq_length=2048,       # 序列最大长度
    load_in_4bit=False,        # 不启用量化（仅下载）
    device_map="cpu",          # 加载到CPU
    cache_dir=os.getenv("TRANSFORMERS_CACHE")  # 使用自定义缓存路径
)

# 3. 保存模型到本地（可选，后续直接加载）
model.save_pretrained("./llama-3.2-1b-local")
print(f"模型保存路径：./llama-3.2-1b-local")

# 后续加载本地模型示例
# model, tokenizer = FastLanguageModel.from_pretrained(
#     model_name="./llama-3.2-1b-local",
#     max_seq_length=2048,
#     load_in_4bit=True,
#     device_map="auto"
# )

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="meta-llama/Llama-3.2-1B-Instruct",  # 或本地路径
    max_seq_length=2048,
    load_in_4bit=True,                  # 启用4-bit量化（降低显存占用）
    use_gradient_checkpointing="unsloth",# Unsloth优化版梯度检查点
    max_lora_rank=16,                   # 降低LoRA秩，减少显存使用
    device_map="auto"
)

# 配置LoRA微调
model = FastLanguageModel.get_peft_model(
    model,
    r=16,                               # LoRA秩（与max_lora_rank一致）
    target_modules=("q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"),
    lora_alpha=32,                      # LoRA缩放因子
    lora_dropout=0.05,                  #  dropout比例（防止过拟合）
    bias="none",
    random_state=3407                   # 固定随机种子（保证可复现）
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="mistralai/Mistral-7B-Instruct-v0.3",  # 7B模型，全参数微调
    max_seq_length=2048,
    load_in_8bit=True,                  # 8-bit量化（平衡精度与显存）
    use_gradient_checkpointing="unsloth",
    optimizer="paged_adamw_8bit",       # 分页优化器（降低显存占用）
    device_map="auto"
)

# 全参数微调无需PEFT配置，直接切换训练模式
model.train()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

from transformers import TrainingArguments, Trainer

training_args = TrainingArguments(
    output_dir="./unsloth_finetune",    # 训练结果输出目录
    per_device_train_batch_size=1,      # 单卡batch size（16GB显存建议1，24GB可尝试2）
    gradient_accumulation_steps=8,      # 梯度累积（等效batch size=1*8=8）
    learning_rate=2e-5,                 # 学习率（全参数微调建议1e-5~3e-5）
    num_train_epochs=3,                 # 训练轮次（避免过拟合）
    logging_steps=10,                   # 日志输出间隔（每10步打印一次损失）
    save_steps=100,                     # 模型保存间隔（每100步保存一次）
    fp16=True,                          # 启用混合精度训练（加速且省显存）
    optim="paged_adamw_8bit",           # 8-bit优化器（降低显存占用）
    report_to="none",                   # 暂不启用监控工具（后续单独配置）
    evaluation_strategy="steps",        # 按步验证
    eval_steps=100,                     # 验证间隔（每100步验证一次）
    load_best_model_at_end=True         # 训练结束加载最优模型
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# 初始化Trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
)

# 开始训练
print("训练启动，日志将按配置间隔输出...")
trainer.train()

# 保存最终模型
trainer.save_model("./fine_tuned_model")
tokenizer.save_pretrained("./fine_tuned_model")
print(f"微调完成，模型保存路径：./fine_tuned_model")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

from torch.utils.tensorboard import SummaryWriter

# 创建日志目录
tb_writer = SummaryWriter(log_dir="./unsloth_finetune/tensorboard")

# 定义监控回调（记录损失、学习率）
def tb_callback(trainer, args, state, control, **kwargs):
    if state.global_step % args.logging_steps == 0:
        # 记录训练损失
        train_loss = state.log_history[-1].get("loss", 0.0)
        tb_writer.add_scalar("Train/Loss", train_loss, state.global_step)
        # 记录学习率
        lr = trainer.optimizer.param_groups[0]["lr"]
        tb_writer.add_scalar("Train/Learning_Rate", lr, state.global_step)
        # 记录验证损失（若有）
        if "eval_loss" in state.log_history[-1]:
            eval_loss = state.log_history[-1]["eval_loss"]
            tb_writer.add_scalar("Eval/Loss", eval_loss, state.global_step)

# 重新初始化Trainer（添加回调）
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
    callbacks=[tb_callback]
)

# 启动训练后，新终端执行TensorBoard（替换为实际路径）
# tensorboard --logdir ./unsloth_finetune/tensorboard
# 浏览器访问：http://localhost:6006

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

# 1. 安装并登录WandB（终端执行）
pip install wandb
wandb login
# 按提示输入API密钥（从WandB官网：https://wandb.ai/settings获取）
import wandb

# 初始化WandB项目
wandb.init(
    project="unsloth-single-gpu-finetune",  # 项目名称（自定义）
    name="llama-3.2-1b-medical-qa",         # 实验名称（自定义）
    config={                                # 记录实验参数（便于复现）
        "model_name": "meta-llama/Llama-3.2-1B-Instruct",
        "batch_size": 1,
        "gradient_accumulation_steps": 8,
        "learning_rate": 2e-5,
        "epochs": 3,
        "max_seq_length": 2048
    }
)

# 配置TrainingArguments（启用WandB报告）
training_args.report_to = "wandb"

# 重新初始化Trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
)

# 启动训练
trainer.train()

# 训练结束后关闭WandB
wandb.finish()
# 浏览器访问WandB项目页面查看监控：https://wandb.ai/你的用户名/unsloth-single-gpu-finetune

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

from unsloth import FastLanguageModel
import torch

# 加载微调后的模型
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="./fine_tuned_model",  # 微调后模型路径
    max_seq_length=2048,
    load_in_4bit=True,
    device_map="auto"
)

def generate_response(prompt, system_prompt="你是专业医疗问答助手"):
    """生成模型回复"""
    # 构建对话格式
    messages = [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": prompt}
    ]
    
    # 编码输入
    inputs = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        return_tensors="pt"
    ).to(model.device)
    
    # 生成回复
    outputs = model.generate(
        inputs,
        max_new_tokens=512,  # 单条回复最大长度
        temperature=0.7,     # 随机性（0-1，越低越稳定）
        top_p=0.9,           # 采样阈值（过滤低概率词）
        do_sample=True,      # 启用采样生成（避免重复）
        pad_token_id=tokenizer.eos_token_id
    )
    
    # 解码输出（去除特殊字符）
    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    # 提取assistant回复
    assistant_response = response.split("assistant")[-1].strip()
    return assistant_response

# 测试推理
test_prompts = [
    "高血压患者可以吃鸡蛋吗？",
    "感冒发烧到38.5℃需要吃退烧药吗？"
]

for prompt in test_prompts:
    print(f"用户：{prompt}")
    response = generate_response(prompt)
    print(f"助手：{response}\n")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

# 安装Flask依赖
pip install flask flask-cors
from flask import Flask, request, jsonify
from flask_cors import CORS
from unsloth import FastLanguageModel
import torch

# 初始化Flask应用
app = Flask(__name__)
CORS(app)  # 允许跨域请求（前端调用）

# 加载微调后的模型（服务启动时加载）
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="./fine_tuned_model",
    max_seq_length=2048,
    load_in_4bit=True,
    device_map="auto"
)

# 定义推理接口（POST方法）
@app.route("/generate", methods=["POST"])
def generate():
    try:
        # 获取请求参数
        data = request.json
        prompt = data.get("prompt", "")
        system_prompt = data.get("system_prompt", "你是专业医疗问答助手")
        max_new_tokens = data.get("max_new_tokens", 512)
        temperature = data.get("temperature", 0.7)
        
        # 校验参数
        if not prompt.strip():
            return jsonify({"code": 400, "message": "prompt不能为空"}), 400
        
        # 生成回复
        messages = [
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": prompt}
        ]
        
        inputs = tokenizer.apply_chat_template(
            messages,
            add_generation_prompt=True,
            return_tensors="pt"
        ).to(model.device)
        
        outputs = model.generate(
            inputs,
            max_new_tokens=max_new_tokens,
            temperature=temperature,
            top_p=0.9,
            do_sample=True,
            pad_token_id=tokenizer.eos_token_id
        )
        
        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
        assistant_response = response.split("assistant")[-1].strip()
        
        # 返回结果
        return jsonify({
            "code": 200,
            "message": "success",
            "data": {
                "prompt": prompt,
                "response": assistant_response
            }
        })
    
    except Exception as e:
        # 异常处理
        return jsonify({
            "code": 500,
            "message": f"服务器错误：{str(e)}"
        }), 500

# 启动服务（生产环境建议用Gunicorn，此处为测试用）
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000, debug=False)

# API测试命令（终端执行，替换为实际参数）
# curl -X POST http://localhost:5000/generate \
# -H "Content-Type: application/json" \
# -d '{"prompt":"高血压患者可以吃鸡蛋吗？", "max_new_tokens":300, "temperature":0.6}'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 导出GGUF格式（支持Ollama、 llama.cpp等工具）
model.save_pretrained_gguf(
    "./exported_model_gguf",  # 输出目录
    tokenizer,
    quantization_method="q4_k_m"  # 量化方式（平衡精度与速度）
)

# Ollama部署命令（终端执行）
# 1. 创建Modelfile
# FROM ./exported_model_gguf/your_model.gguf
# 2. 构建Ollama模型
# ollama create medical-qa -f Modelfile
# 3. 启动对话
# ollama run medical-qa