from __future__ import annotations import json import shutil from pathlib import Path import torch from datasets import load_dataset from peft import ( LoraConfig, get_peft_model, prepare_model_for_kbit_training, ) from transformers import ( AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, ) from trl import SFTConfig, SFTTrainer PROJECT_ROOT = Path(__file__).resolve().parent.parent CONFIG_PATH = PROJECT_ROOT / "config" / "pipeline.json" CHAT_TEMPLATE_PATH = PROJECT_ROOT / "config" / "chat_template.jinja" def to_prompt_completion(example: dict) -> dict: messages = example["messages"] if len(messages) != 3: raise ValueError( f"Record {example.get('id')} does not contain three messages." ) return { "prompt": messages[:2], "completion": [messages[2]], } def load_split(path: Path): dataset = load_dataset( "json", data_files=str(path), split="train", ) return dataset.map( to_prompt_completion, remove_columns=dataset.column_names, desc=f"Preparing {path.name}", ) def main() -> None: config = json.loads(CONFIG_PATH.read_text(encoding="utf-8")) model_config = config["model"] training_config = config["training"] full_config = training_config["full"] lora_settings = training_config["lora"] model_path = model_config["base_model"] output_dir = PROJECT_ROOT / full_config["output_dir"] if output_dir.exists(): shutil.rmtree(output_dir) print("Loading datasets...") train_dataset = load_split( PROJECT_ROOT / config["paths"]["train"] ) validation_dataset = load_split( PROJECT_ROOT / config["paths"]["validation"] ) print(f"Training records: {len(train_dataset)}") print(f"Validation records: {len(validation_dataset)}") print("Loading tokenizer...") tokenizer = AutoTokenizer.from_pretrained( model_path, use_fast=True, ) tokenizer.chat_template = CHAT_TEMPLATE_PATH.read_text( encoding="utf-8" ) if tokenizer.pad_token_id is None: tokenizer.pad_token = tokenizer.eos_token tokenizer.padding_side = "right" quantization_config = BitsAndBytesConfig( load_in_4bit=True, bnb_4bit_quant_type="nf4", bnb_4bit_use_double_quant=True, bnb_4bit_compute_dtype=torch.bfloat16, ) print("Loading base model in 4-bit NF4...") model = AutoModelForCausalLM.from_pretrained( model_path, quantization_config=quantization_config, dtype=torch.bfloat16, device_map={"": 0}, low_cpu_mem_usage=True, ) model.config.use_cache = False model = prepare_model_for_kbit_training( model, use_gradient_checkpointing=True, gradient_checkpointing_kwargs={ "use_reentrant": False, }, ) lora_config = LoraConfig( task_type="CAUSAL_LM", r=int(lora_settings["rank"]), lora_alpha=int(lora_settings["alpha"]), lora_dropout=float(lora_settings["dropout"]), target_modules=lora_settings["target_modules"], bias="none", ) model = get_peft_model(model, lora_config) model.print_trainable_parameters() training_args = SFTConfig( output_dir=str(output_dir), max_length=int(model_config["max_sequence_length"]), num_train_epochs=float(full_config["epochs"]), per_device_train_batch_size=int( full_config["batch_size"] ), per_device_eval_batch_size=int( full_config["batch_size"] ), gradient_accumulation_steps=int( full_config["gradient_accumulation_steps"] ), learning_rate=float(full_config["learning_rate"]), warmup_steps=int(full_config["warmup_steps"]), lr_scheduler_type="cosine", logging_steps=int(full_config["logging_steps"]), eval_strategy="epoch", save_strategy="epoch", save_total_limit=2, load_best_model_at_end=True, metric_for_best_model="eval_loss", greater_is_better=False, bf16=True, tf32=True, gradient_checkpointing=True, gradient_checkpointing_kwargs={ "use_reentrant": False, }, optim="adamw_torch_fused", completion_only_loss=True, packing=False, report_to="none", seed=int(full_config["seed"]), data_seed=int(full_config["seed"]), ) trainer = SFTTrainer( model=model, args=training_args, train_dataset=train_dataset, eval_dataset=validation_dataset, processing_class=tokenizer, ) torch.cuda.reset_peak_memory_stats() print() print("Starting full training...") result = trainer.train() trainer.save_model(str(output_dir)) tokenizer.save_pretrained(str(output_dir)) trainer.save_state() peak_memory = torch.cuda.max_memory_allocated() / 1024**3 print() print("Full training passed.") print(f"Output: {output_dir}") print(f"Training loss: {result.training_loss:.6f}") print(f"Peak GPU memory: {peak_memory:.2f} GiB") if __name__ == "__main__": main()