尝试对对中文数据进行finetune验证，测试模型的可优化方向。下面是代码的详细情况

代码实现

from datasets import load_dataset
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
    HfArgumentParser,
    AutoTokenizer,
    TrainingArguments,
    Trainer,
    GenerationConfig
)
from tqdm import tqdm
from trl import SFTTrainer
import torch
import time
import pandas as pd
import numpy as np
from huggingface_hub import interpreter_login
from datasets import Dataset, DatasetDict
from functools import partial
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
import os
# 禁用权重和偏差
os.environ['WANDB_DISABLED']="true"

中文摘要相关数据

git clone https://www.modelscope.cn/datasets/DAMO_NLP/lcsts_test_set.git

data_train_pth ='../Fine-tune/data/lcsts_test_set/{}'.format('train.csv')
data_train = pd.read_csv(data_train_pth)

data_test_pth = '../Fine-tune/data/lcsts_test_set/{}'.format('test.csv')
data_test = pd.read_csv(data_test_pth)

print(data_train.shape)
print(data_test.shape)

data_train.head()

数据加载

#这里看到原本的训练集合很大
data_train = data_train.head(3000)

data_train = Dataset.from_pandas(data_train)
data_test = Dataset.from_pandas(data_test)

print(data_train)

模型加载

compute_dtype = getattr(torch, "float16")
bnb_config = BitsAndBytesConfig(
        load_in_4bit=True,
        bnb_4bit_quant_type='nf4',
        bnb_4bit_compute_dtype=compute_dtype,
        bnb_4bit_use_double_quant=False,
    )
model_name=r'G:\hugging_fase_model2\Qwen1.5-7B-Chat'
device_map = {"": 0}
original_model = AutoModelForCausalLM.from_pretrained(model_name, 
                                                      device_map=device_map,
                                                      quantization_config=bnb_config,
                                                      trust_remote_code=True,
                                                      use_auth_token=True)

tokenizer = AutoTokenizer.from_pretrained(model_name,trust_remote_code=True,padding_side="left",add_eos_token=True,add_bos_token=True,use_fast=False)
tokenizer.pad_token = tokenizer.eos_token                                                      

数据预处理

def create_prompt_formats(sample):
    """
    格式化示例的各个字段('instruction'，'output')
    然后使用两个换行符将它们连接起来
    :参数sample:样本字典
    """
    ROLE_PROMPT = "### 你是一个新闻工作者。"#校色说明
    INTRO_BLURB = " ###需要给文章起一个合适的标题，这里会给到已有的文章和标题，需要学习如何给文章起标题名称"#任务简介
    INSTRUCTION_KEY = "###文章内容：以下是文章的内容，"
    RESPONSE_KEY =  "### 标题名称:"
    END_KEY = "### 结束"

    role= f"\n{ROLE_PROMPT}"
    blurb = f"\n{INTRO_BLURB}"
    instruction = f"{INSTRUCTION_KEY}"
    input_context = f"{sample['text1']}" if sample["text1"] else None
    response = f"{RESPONSE_KEY}\n{sample['text2']}"
    end = f"{END_KEY}"
    
    parts = [part for part in [role,blurb, instruction, input_context, response, end] if part]

    formatted_prompt = "\n\n".join(parts)
    sample["text"] = formatted_prompt

    return sample

def get_max_length(model):
    conf = model.config
    max_length = None
    for length_setting in ["n_positions", "max_position_embeddings", "seq_length"]:
        max_length = getattr(model.config, length_setting, None)
        if max_length:
            print(f"Found max lenth: {max_length}")
            break
    if not max_length:
        max_length = 1024
        print(f"Using default max length: {max_length}")
    return max_length


def preprocess_batch(batch, tokenizer, max_length):
    """
    token处理
    """
    return tokenizer(
        batch["text"],
        max_length=max_length,
        truncation=True,
    )
    
def preprocess_dataset(tokenizer: AutoTokenizer, max_length: int,seed, dataset):
    """
    格式化并标记它，以便为培训做好准备
    参数标记器(AutoTokenizer):模型标记器
    :param max_length (int):从标记器发出的标记的最大数量
    """
    
    # 在每个示例中添加提示
    print("开始数据预处理...")
    dataset = dataset.map(create_prompt_formats)#, batched=True)
    
    # 对每一批数据集&进行预处理
    _preprocessing_function = partial(preprocess_batch, max_length=max_length, tokenizer=tokenizer)
    dataset = dataset.map(
        _preprocessing_function,
        batched=True,
        remove_columns=['text1', 'text2'],
    )

    # 过滤掉input_ids超过max_length的样本
    dataset = dataset.filter(lambda sample: len(sample["input_ids"]) < max_length)
    
    # 打乱数据
    dataset = dataset.shuffle(seed=seed)

    return dataset

## 预处理
max_length = get_max_length(original_model)
print(max_length)

seed=123
train_data = preprocess_dataset(tokenizer, max_length,seed, data_train)
eval_data = preprocess_dataset(tokenizer, max_length,seed, data_test)

模型训练

output_dir = f'./QWEn_peft-dialogue-summary-training-{str(int(time.time()))}'
peft_config = LoraConfig(
        lora_alpha=16, 
        lora_dropout=0.1,
        r=64,
        bias="none",
        target_modules="all-linear",
        task_type="CAUSAL_LM",
        #inplace=False,
        #target_modules=[
        #    'q_proj',
        #    'k_proj',
        #    'v_proj',
        #    'dense'
    #],
)




training_arguments = TrainingArguments(
    output_dir=output_dir,                    # 保存训练日志和检查点的目录
    num_train_epochs=5,                       # 为其训练模型的历元数。一个epoch通常指的是通过整个训练数据集一次的前向传播和反向传播过程。
    #num_train_epochs 被设置为3，意味着模型将完整地遍历训练数据集3次。
    per_device_train_batch_size=1,            # 每个设备上每个批次的样本数。
    gradient_accumulation_steps=8,            #  执行向后/更新过程之前的步骤数
    gradient_checkpointing=True,              # 使用渐变检查点保存内存
    optim="paged_adamw_8bit",                 #"paged_adamw_8bit"/"paged_adamw_32bit" 用于训练模型的优化器
    save_steps=50,
    logging_steps=50,                         # 记录训练指标的步骤数。它被设置为50，意味着每50个训练步骤，训练指标将被记录一次。
    learning_rate=2e-4,                       # 学习率
    weight_decay=0.001,
    fp16=True,
    bf16=False,
    max_grad_norm=0.3,                        # 基于QLoRA的最大梯度范数
    max_steps=500, #1000,                     #这个建议设置上，不然会出现很多次的训练轮
    warmup_ratio=0.03,                        # 基于QLoRA的预热比
    group_by_length=True,
    lr_scheduler_type="cosine",               # 使用余弦学习率调度
    report_to="tensorboard",                  # 向tensorboard报告指标  可选"none"
    evaluation_strategy="epoch",               # 每个纪元保存检查点 可选"steps" 这个参数设置了评估策略。
    #代码中设置为"epoch"，意味着评估将在每个epoch结束后进行。由于eval_steps也设置为50，这可能意味着评估将在每50个训练步骤或每个epoch
    #warmup_steps = 1
    #logging_dir="./logs",
    save_strategy="steps",
    eval_steps=50,#意味着每50个训练步骤，模型将在验证集上进行一次评估。
    do_eval=True,
    overwrite_output_dir  =True
)
"""
上述参数，模型将在以下情况下停止训练：

完成3个epoch的训练，无论eval_steps条件是否满足。
如果训练数据集的大小导致在3个epoch内无法达到50个训练步骤，那么模型将在完成所有训练步骤后停止。
至于评估输出，由于logging_steps和eval_steps都设置为50，这意味着：

每50个训练步骤，训练指标将被记录一次。
每50个训练步骤，模型将在验证集上进行一次评估。
"""


#training_arguments.config.use_cache = False
#transformers.Trainer
"""
transformers.Trainer：如果你有一个大的数据集，并且需要为你的培训循环或复杂的培训工作流程进行广泛的定制。
使用SFTTrainer：如果你有一个预训练的模型和相对较小的数据集，并且想要更简单、更快的微调体验和高效的内存使用。

如果训练数据集较小，可能导致在每个epoch中训练步骤数少于50步，那么eval_steps条件可能不会触发，评估将在每个epoch结束后根据evaluation_strategy参数的设置进行。

另外，max_steps参数通常用于设置训练的最大步骤数，以防止训练超过预定的epoch数。
代码中，max_steps被设置为1000，这个值远大于由num_train_epochs和per_device_train_batch_size参数隐式定义的训练步骤数。
因此，除非训练数据集非常大，否则这个参数在上下文中可能不会起作用。
如果max_steps的值大于完成所有epoch所需步骤数的总和，训练将在完成所有epoch后停止，而不是在达到max_steps指定的步骤数时停止。
"""
trainer = SFTTrainer(
    model=original_model,
    args=training_arguments,#
    train_dataset=train_data,
    eval_dataset=eval_data,
    peft_config=peft_config,# 模型配置文件
    dataset_text_field="text",
    tokenizer=tokenizer,
    max_seq_length=1024,
    packing=False,
    dataset_kwargs={
        "add_special_tokens": False,
        "append_concat_token": False,
    }
)

"""
#可选
trainer = transformers.Trainer(
    model=peft_model,
    train_dataset=train_data,
    eval_dataset=eval_data,
    args=training_arguments,
    data_collator=transformers.DataCollatorForLanguageModeling(tokenizer, mlm=False),
)
"""

trainer.train()
#模型保存
trainer.save_model()
#保存token
tokenizer.save_pretrained(output_dir)

运行结果：

这里看到loss 没有很好的出现下降的情况

其他方案调整

调整promt 工程

告诉大模型 任务是文本的摘要

尝试调整

调整学习率1e-4

只是延缓了过拟合的情况发生。

增加训练集

后期过拟合的只有更快了。
以上是文本的全部内容，有好的方法希望一起讨论。感谢。