import os
import torch
from unsloth import FastLanguageModel
from unsloth import is_bfloat16_supported
from trl import SFTTrainer, GRPOConfig, GRPOTrainer
from datasets import load_dataset
from transformers import TrainingArguments

class ModelTrainer:
    def __init__(self, model_name, max_seq_length, dtype, load_in_4bit,lora_rank=32):
        # 初始化 ModelTrainer 类，设置模型名称、最大序列长度、数据类型和是否以4位加载
        self.model_name = model_name
        self.max_seq_length = max_seq_length
        self.dtype = dtype         # dtype: 数据类型，如 torch.float16 或 torch.bfloat16
        self.load_in_4bit = load_in_4bit         # load_in_4bit: 是否以4位精度加载模型，用于节省显存
        self.lora_rank=lora_rank  #Larger rank = smarter, but slower

    def load_model(self):
        # 加载预训练模型和分词器
        model, tokenizer = FastLanguageModel.from_pretrained(
            model_name=self.model_name,
            max_seq_length=self.max_seq_length,
            load_in_4bit=self.load_in_4bit, # 值为True 以 4 bit量化进行微调，为False LoRA 16bit。这将内存使用量减少了 4 倍，使我们能够在免费的 16GB 内存 GPU 中实际进行微调。4 位量化本质上将权重转换为一组有限的数字以减少内存使用量。这样做的缺点是准确度会下降 1-2%。如果您想要这种微小的额外准确度，请在较大的 GPU（如 H100）上将其设置为 False。
            dtype=self.dtype,
            fast_inference = True, # Enable vLLM fast inference
            max_lora_rank = lora_rank,
            gpu_memory_utilization=0.6,# Reduce if out of memory
        )
        
        # 添加 LoRA 适配器
        model = FastLanguageModel.get_peft_model(
            model,
            max_seq_length=self.max_seq_length,  # 最大上下文（序列）长度
            r=16,  # LoRA 的秩，控制适配器的复杂度
            target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                          "gate_proj", "up_proj", "down_proj"],  # 应用 LoRA 的目标模块
            lora_alpha=16,  # LoRA 的 alpha 参数，控制适配器的缩放
            lora_dropout=0,  # LoRA 的 dropout 率，设置为0以优化性能
            bias="none",     # 是否在 LoRA 中添加偏置，设置为 "none" 以优化性能
            use_gradient_checkpointing="unsloth",  # 使用梯度检查点以节省显存,对于非常长的上下文，使用 True 或 "unsloth"
            random_state=3407,  # 随机种子，确保实验可复现
            use_rslora=False,  # 是否使用 rank stabilized LoRA，当前不支持
            loftq_config=None,  # LoftQ 配置，当前不支持
        )

        return model, tokenizer

    def load_data(self, train_data_path):
        # 加载训练集和测试集
        train_dataset = load_dataset("json", data_files={"train": train_data_path}, split="train")
        # train_data_path: 训练数据路径，格式为 JSONL
        return train_dataset

    def train(self, model, tokenizer, train_dataset):
        print("is_bfloat16_supported()=",is_bfloat16_supported())
        # 初始化 SFTTrainer
        trainer = SFTTrainer(
            model=model,
            tokenizer=tokenizer,
            train_dataset=train_dataset,
            dataset_text_field="text",  # 指定数据集中包含文本的字段
            max_seq_length=self.max_seq_length, # 最大上下文长度
            dataset_num_proc =2 ,
            packing =False,  # Can make training 5x faster for short sequences
            args=TrainingArguments(
                per_device_train_batch_size=2,  # 每个设备的训练批次大小
                gradient_accumulation_steps=4,  # 梯度累积步数，用于模拟更大的批次
                warmup_steps=10,  # 学习率预热步数
                max_steps=100,  # 最大训练步数
                learning_rate =1e-4, # 学习率
                fp16=not is_bfloat16_supported(),  # 是否使用 FP16 精度
                bf16=is_bfloat16_supported(),  # 是否使用 BF16 精度
                logging_steps=1,  # 日志记录步数间隔
                optim="adamw_8bit",  # 优化器，使用 8 位 AdamW
                weight_decay=0.01,
                lr_scheduler_type="linear", 
                seed=3407,  # 随机种子，确保实验可复现
                output_dir="outputs",  # 输出目录
            ),
        )
        
        # 训练模型
        trainer.train()
        
        return model

    def save_model(self, model, tokenizer, save_path):
        # 保存模型和分词器
        model.save_pretrained(save_path)
        tokenizer.save_pretrained(save_path)
        print(f"Model saved to {save_path}")

if __name__ == "__main__":
    # 配置参数
    model_name = os.path.join('..', 'models', 'pretrained', 'DeepSeek-R1-Distill-Qwen-1.5B')
    # model_name: 预训练模型的路径
    max_seq_length = 2048  # 最大序列长度
    dtype = torch.float16  # 数据类型
    load_in_4bit = True  # 是否以4位精度加载模型
    lora_rank=32

    # 定义训练集和测试集路径
    train_data_path = os.path.join('..', 'data', 'processed', 'train.jsonl')
    # train_data_path: 训练数据路径

    # 初始化 ModelTrainer
    trainer = ModelTrainer(model_name, max_seq_length, dtype, load_in_4bit)
    
    # 加载模型和分词器
    model, tokenizer = trainer.load_model()

    # 加载数据集
    train_dataset = trainer.load_data(train_data_path)

    # 训练模型
    model = trainer.train(model, tokenizer, train_dataset)

    # 保存模型
    save_path = os.path.join('..', 'models', 'trained', 'DeepSeek-R1-Distill-Qwen-1.5B')
    trainer.save_model(model, tokenizer, save_path)