基于DeepSeek-R1-Distill-Qwen-1.5B 法律大模型Lora微调

基于DeepSeek-R1-Distill-Qwen-1.5B基座大模型，刑法数据集，lora微调一个法律大模型

球球别报错了啊

352人浏览 · 2025-04-29 17:27:16

球球别报错了啊 · 2025-04-29 17:27:16 发布

准备工作

准备依赖

nvidia显卡信息

主要python 依赖，torch要下载gpu版本哦

pytorch                   2.5.1 
python                    3.10.16
transformers              4.51.3  
peft                      0.15.2  
peft                      0.15.2

验证是否安装gpu版本

import torch
print(torch.__version__)
print(torch.cuda.is_available())

这里测试一下输出效果

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import get_peft_config, get_peft_model, LoraConfig, TaskType, AutoPeftModelForCausalLM

model_name_or_path = "H:\\models\\DeepSeek-R1-Distill-Qwen-1.5B"

tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)
# 定义一个提示（prompt），这是一个问题，要求模型对大型语言模型进行简短介绍。
prompt = "如果运输他人偷渡边境，如果被运人受伤，处罚是啥"
# ③创建一个消息列表
messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": prompt}
]
# ④将对话消息格式化为一个适合模型输入的字符串
text = tokenizer.apply_chat_template(
    messages,
    tokenize=False,  # 表示不对输入进行分词，
    add_generation_prompt=True  # 表示添加生成提示。
)
model = AutoModelForCausalLM.from_pretrained(
    model_name_or_path,
    device_map="auto",
)
# ⑤将字符串转换为模型需要的输入格式，这里指定返回的格式为PyTorch张量，然后将张量移动到之前定义的设备上。
model_inputs = tokenizer([text], return_tensors="pt").to("cuda")
# ⑥使用模型的 generate 方法生成文本，max_new_tokens=512 限制生成的token数量最多为512个。
generated_ids = model.generate(
    model_inputs.input_ids,
    max_new_tokens=512
)

# ⑦从生成的token中提取新的文本内容，忽略原始输入的token，只保留输出的token。
generated_ids = [
    output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
]
# ⑧使用分词器的 batch_decode 方法将生成的token解码回文本，并使用 skip_special_tokens=True 忽略特殊的token，然后获取解码后的文本作为模型的响应。
response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
print(response)

嗯，我现在需要回答关于被运输到边境偷渡的人受伤时，可能的处罚是什么。首先，我得回想一下相关法律和政策。在很多国家，偷渡是非法的，所以即使有人偷渡到边境，如果被运到那里，可能会受到法律的制裁。

首先，偷渡本身是违法行为，违反了国际法律，所以被运到边境后，通常会面临法律后果。接下来，如果被运到边境后受伤，那可能需要根据受伤的严重程度来决定处罚。受伤的程度不同，处罚可能会不同。

我应该考虑不同的受伤情况。比如，轻微的伤害，可能由法律决定，比如罚款或者剥夺劳动权。如果伤势较重，可能需要 longer stay or even prison time。另外，如果被运到边境后不久就死亡，那可能会面临更严重的处罚，比如终身禁运或更严厉的法律制裁。

另外，我应该考虑到是否有其他法律程序，比如国际人权法中的权利保护，但我觉得这可能超出了普通人的法律范畴，可能需要咨询专业人士。所以，在回答时，我需要明确说明这些法律后果，并建议咨询相关法律专业人士。

总结一下，主要的处罚包括：罚款或剥夺劳动权，更长的停留时间，或更严重的处罚如禁运或更严厉的法律制裁。同时，也要提到如果受伤严重，可能需要更紧急的处理。

现在，我需要把这些信息组织成一个有条理的回答，确保涵盖所有可能的情况，并给出具体的处罚建议。
</think>

如果运输他人偷渡到边境并受伤，通常会面临以下法律后果：

1. **法律制裁**：
   - **罚款或剥夺劳动权**：根据受伤的严重程度，可能由法律决定给予罚款或剥夺劳动权，以维护个人权益。
   - **更长的停留时间**：严重受伤可能导致更长时间的关押，甚至可能面临更严厉的法律制裁。

2. **紧急处理**：
   - 如果受伤严重，可能需要立即采取行动，寻求医疗帮助或法律援助，以确保自己的安全。

3. **国际人权法**：
   - 如果受伤严重，可能违反国际人权法，受到更严厉的处罚，但这些通常由专业人士评估。

建议咨询相关法律专业人士，以获得准确和详细的法律建议。

这里效果并不是我们需要的，甚至输出了一些异常字符

准备文件

模型文件

这里是modelscope下载的 deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5Bhttps://modelscope.cn/models/deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B

魔搭社区

数据文件，数据是Unicode 编码的

刑法数据魔搭社区

代码微调

from turtle import pd

import torch
from datasets import Dataset
from transformers import AutoTokenizer, TrainingArguments, EarlyStoppingCallback
import pandas as pd
from transformers import AutoTokenizer, AutoModelForCausalLM, DataCollatorForSeq2Seq, TrainingArguments, Trainer, GenerationConfig
from peft import LoraConfig, TaskType, get_peft_model, PeftModel



model_name_or_path = "H:\\models\\DeepSeek-R1-Distill-Qwen-1.5B"


tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)
#处理数据
def process_func(example):
    MAX_LENGTH = 2048  # 分词器会将一个中文字切分为多个token，因此需要放开一些最大长度，保证数据的完整性
    input_ids, attention_mask, labels = [], [], []
    instruction = tokenizer(
        f"<im_start>system\n{example['instruction']}<|im_end|>\n<|im_start|>user{example['input']}<|im_end|>\n<|im_start|>assistant\n",
        add_special_tokens=False)  # add_special_tokens 不在开头加 special_tokens
    response = tokenizer(f"{example['output']}", add_special_tokens=False)
    input_ids = instruction["input_ids"] + response["input_ids"] + [tokenizer.pad_token_id]
    attention_mask = instruction["attention_mask"] + response["attention_mask"] + [1]  # 因为eos token咱们也是要关注的所以 补充为1
    labels = [-100] * len(instruction["input_ids"]) + response["input_ids"] + [tokenizer.pad_token_id]
    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
    }

def train_lora(model, tokenizer):
    model.enable_input_require_grads() # 开启梯度检查点时，要执行该方法
    # LoRA模型
    config = LoraConfig(
        task_type=TaskType.CAUSAL_LM,
        target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"], # 需要微调的参数
        inference_mode=False, # 训练模式
        r=8, # Lora 秩
        lora_alpha=32, # Lora alaph，具体作用参见 Lora 原理
        lora_dropout=0.1# Dropout 比例
    )
    model = get_peft_model(model, config)
    # 训练参数配置
    lora_path = "H:\\models\\DeepSeek-R1-Distill-Qwen-1.5B\\lora"
    # args = TrainingArguments(
    #     output_dir=lora_path,
    #     per_device_train_batch_size=8,
    #     gradient_accumulation_steps=8,
    #     logging_steps=50,
    #     num_train_epochs=5,
    #     save_steps=500,
    #     learning_rate=5e-5,
    #     save_on_each_node=True,
    #     gradient_checkpointing=True,
    #     evaluation_strategy="steps",
    #     eval_steps=500,  # 每500步进行一次评估
    #     load_best_model_at_end=True,  # 训练结束后加载最佳模型
    #     metric_for_best_model="eval_loss",  # 根据验证损失选择最佳模型
    #     greater_is_better=False  # 验证损失越小越好
    # )

    args = TrainingArguments(
        output_dir=lora_path,
        per_device_train_batch_size=8,
        gradient_accumulation_steps=8,
        logging_steps=50,
        num_train_epochs=5,
        save_steps=500,
        learning_rate=5e-5,
        save_on_each_node=True,
        gradient_checkpointing=True
    )
    df_train = pd.read_json('H:\\\models\datasets\\alpaca_dataset.json')
    ds_train = Dataset.from_pandas(df_train)
    tokenized_id = ds_train.map(process_func, remove_columns=ds_train.column_names)
    trainer = Trainer(
        model=model,
        args=args,
        train_dataset=tokenized_id,
        data_collator=DataCollatorForSeq2Seq(tokenizer=tokenizer, padding=True),
    )
    trainer.train()

    trainer.save_model(lora_path + "/final")
if __name__ == '__main__':
    # 底座模型

    tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, use_fast=False, trust_remote_code=True)
    model = AutoModelForCausalLM.from_pretrained(model_name_or_path, device_map="auto", torch_dtype=torch.bfloat16, trust_remote_code=True)
    train_lora(model, tokenizer)

代码微调完成会生成一个lora目录，里面有adapter_model

合并模型

这里可以自己加载lora文件，我这里选择合并模型

import torch
from peft import PeftModel
from transformers import AutoTokenizer, AutoModelForCausalLM


def merge_model(model):
    lora_path = "H:\\models\\DeepSeek-R1-Distill-Qwen-1.5B\lora\\final"
    merge_path = "./output/qwen2_1.5b_novel/merged"
    # 加载lora权重
    model = PeftModel.from_pretrained(model, model_id=lora_path)
    merged_model = model.merge_and_unload()
    # 将权重保存为safetensors格式的权重, 且每个权重文件最大不超过2GB(2048MB)
    merged_model.save_pretrained(merge_path, max_shard_size="2048MB", safe_serialization=True)
if __name__ == '__main__':
    # 底座模型
    model_path = "H:\\models\\DeepSeek-R1-Distill-Qwen-1.5B"
    tokenizer = AutoTokenizer.from_pretrained(model_path, use_fast=False, trust_remote_code=True)
    model = AutoModelForCausalLM.from_pretrained(model_path, device_map="auto", torch_dtype=torch.bfloat16,
                                                 trust_remote_code=True)
    merge_model(model)

合并完成后，模型在当前文件目录output下

加载模型测试对话

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

# 检查 CUDA 是否可用
device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Using device: {device}")

# 加载预训练的分词器和模型
model_name = "H:\\code\\PEFT\\output\\qwen2_1.5b_novel\\merged"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name).to(device)

# 输入文本
input_text = "如果运输他人偷渡边境，如果被运人受伤，处罚是啥"

# 对输入文本进行分词
input_ids = tokenizer(input_text, return_tensors="pt").input_ids.to(device)

# 进行推理
output = model.generate(input_ids, max_length=400, num_beams=5, no_repeat_ngram_size=2)

# 解码输出结果
output_text = tokenizer.decode(output[0].cpu(), skip_special_tokens=True)

print(output_text)

输出结果

如果运输他人偷渡边境，如果被运人受伤，处罚是啥？

根据《中华人民共和国刑法》第二百三十四条之一的规定，对于被运输的人员发生严重后果的，处三年以下有期徒刑或者拘役，并处或者单处罚金；如果后果特别严重，将被处以三年以上七年以下的有期徒刑。这表明了法律对于此类行为的严厉态度，旨在通过严厉的惩罚来震慑潜在的犯罪行为，保护边境地区的安全和居民的生命财产安全。

输出结合和数据集里面的内容基本能对上