24小时驯服AI!零基础调教DeepSeek教程

你是否好奇DeepSeek如何变身行业专家？ 想用1台家用显卡训练AI安全卫士？ 本文带你解锁大模型微调黑科技！

一、1分钟搞懂大模型微调原理（小白秒懂版）

1.1 大模型为什么需要"二次加工"

• 预训练模型 ≈ 通才：懂100+种技能但都不精
• 微调（Fine-tuning）≈ 特训班：注入垂直领域灵魂
• 网络安全特训：让模型看懂0day漏洞/识别攻击日志

1.2 低成本秘诀-LoRA黑科技

传统微调：改全部参数 → 需要A100显卡 × 10天 LoRA微调：仅改0.1%参数 → 家用RTX3090 × 3小时

1.3 准备工作清单

1.注册Kaggle账号（需手机验证）2.创建Notebook：选择"GPU Accelerator"3.上传数据集：点击"+ Add Data"上传安全日志文件4.注册登录HuggingFace账号，并获取User Access Tokens

二、DeepSeek微调实战

第一步：环境依赖安装

%%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

第二步：加载预训练模型

# 导入 Unsloth 提供的 FastLanguageModel 类，用于加载和操作高效的大型语言模型。
from unsloth import FastLanguageModel

# 导入 PyTorch 库，它是深度学习的基础框架，用于处理模型的张量计算和 GPU 加速。
import torch

# 设置模型处理文本的最大序列长度（单位：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 令牌。
)

第三步：微调前测试

# 定义提示模板（prompt_style），这是一个多行字符串，用于格式化输入和输出。
# 模板包含指令、问题和回答部分，设计目的是引导模型生成结构化的回答。
prompt_style = """以下是描述任务的指令，以及提供进一步上下文的输入。
请写出一个适当完成请求的回答。
在回答之前，请仔细思考问题，并创建一个逻辑连贯的思考过程，以确保回答准确无误。

### 指令：
你是一个网络安全领域专家，擅长分析Web安全、渗透测试、逆向等各种问题。
请回答以下网络安全问题。

### 问题：
{}

### 回答：
{}"""

# 定义一个测试问题，用于在微调前检查模型的初始能力。
# 这里选择了一个常见的医疗问题，方便观察模型的表现。
question = "PHP文件上传漏洞如何防御？"

# 将模型切换到推理模式。
# 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])

第四步：加载数据集

train_prompt_style = """以下是描述任务的指令，以及提供进一步上下文的输入。
请写出一个适当完成请求的回答。
在回答之前，请仔细思考问题，并创建一个逻辑连贯的思考过程，以确保回答准确无误。

### 指令：
你是一个网络安全领域专家，擅长分析Web安全、渗透测试、逆向等各种问题。
请回答以下网络安全问题。

### 问题：
{}

### 回答：
<思考>
{}

{}"""

from datasets import load_dataset
dataset = load_dataset("csv", data_files="/kaggle/input/security-data/security_data.csv",split="train")
EOS_TOKEN = tokenizer.eos_token
def format_conversation(example):
    """
    将 Qwen 的对话格式转换成字符串
    """
    inputs = example["Question"]
    cots = example['Complex_CoT3']
    outputs = example['Response']
    texts = []
    for input,cot,output in zip(inputs,cots,outputs):
        text= train_prompt_style.format(input,cot,output)+EOS_TOKEN
        texts.append(text)
    return {"text": texts,}

# 处理数据
dataset = dataset.map(format_conversation,batched=True)
dataset['text'][0]

第五步：执行微调训练

# 将模型切换到训练模式。
# 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，表示不启用。
)

# 导入 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=75,                   # 最大训练步数，控制训练时长（步数 = 数据量 / 批次大小）。
        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()

第六步：微调后测试

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])

第七步：保存模型到本地

new_model_local = "DeepSeek-R1-Security"
model.save_pretrained(new_model_local) 
tokenizer.save_pretrained(new_model_local)
model.save_pretrained_merged(new_model_local, tokenizer, save_method = "merged_16bit",)

第八步：登录Hugging Face CLI

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()

hf_token = user_secrets.get_secret("HuggingFace")
login(hf_token)

第九步：推送模型到 Hugging Face Hub

new_model_online = "AIForSecurity/DeepSeek-R1-Security"
model.push_to_hub(new_model_online)
tokenizer.push_to_hub(new_model_online)
model.push_to_hub_merged(new_model_online, tokenizer, save_method = "merged_16bit")

总结

• 本文通过在kaggle gpu上微调实战，轻松微调了网络安全领域问答数据。
• 从结果来看，微调后的模型回答问题更精准，原始模型回答太宽泛。
  关注公众号【AI安全这点事】 分享更多网络安全前沿技术和论文。