#!/usr/bin/env python3 """ Fine-tune Qwen2.5-Coder:1.5B with QLoRA via Unsloth. Designed for automated RunPod execution. Usage: python3 train_qwen15b_coder.py \\ --train_file /workspace/training-data/train.jsonl \\ --eval_file /workspace/training-data/eval.jsonl \\ --output_dir /workspace/qwen15b-lora-adapter \\ --model_name Qwen/Qwen2.5-Coder-1.5B \\ --lora_r 8 \\ --lora_alpha 16 \\ --batch_size 4 \\ --num_epochs 1 Output: LoRA adapter weights in --output_dir """ import json import os import sys import time import re import argparse import random from pathlib import Path import torch from datasets import Dataset from transformers import TrainingArguments from unsloth import FastLanguageModel, is_bfloat16_supported from trl import SFTTrainer # ── Args ── def parse_args(): p = argparse.ArgumentParser(description="Fine-tune Qwen 1.5B with QLoRA") p.add_argument("--train_file", default="/workspace/training-data/train.jsonl") p.add_argument("--eval_file", default="/workspace/training-data/eval.jsonl") p.add_argument("--output_dir", default="/workspace/qwen15b-lora-adapter") p.add_argument("--model_name", default="unsloth/Qwen2.5-Coder-1.5B") p.add_argument("--lora_r", type=int, default=8) p.add_argument("--lora_alpha", type=int, default=16) p.add_argument("--batch_size", type=int, default=4) p.add_argument("--gradient_accumulation", type=int, default=4) p.add_argument("--learning_rate", type=float, default=2e-4) p.add_argument("--num_epochs", type=int, default=1) p.add_argument("--max_seq_length", type=int, default=2048) p.add_argument("--save_steps", type=int, default=100) p.add_argument("--warmup_steps", type=int, default=20) return p.parse_args() def load_jsonl(path): """Load a JSONL file as a list of dicts.""" records = [] with open(path) as f: for line in f: line = line.strip() if line: records.append(json.loads(line)) return records def format_messages_for_training(record): """Convert messages array to prompt+response text.""" msgs = record.get("messages", []) system = "" prompt_parts = [] response_text = "" for m in msgs: role = m.get("role", "") content = m.get("content", "") if role == "system": system = content elif role == "user": prompt_parts.append(content) elif role == "assistant": response_text = content prompt = f"<|im_start|>system\n{system}<|im_end|>\n" if system else "" prompt += "<|im_start|>user\n" + "\n".join(prompt_parts) + "<|im_end|>\n<|im_start|>assistant\n" return prompt, response_text def scrub_check(records): """Verify no credentials leaked into training data.""" cred_patterns = [ r'ghp_[a-zA-Z0-9]{35,40}', r'gho_[a-zA-Z0-9_]{35,40}', r'github_pat_[a-zA-Z0-9_]{80,90}', r'(?i)(bearer|token|authorization):\s*[a-zA-Z0-9_-]{20,}', r'-----BEGIN (RSA|EC|DSA|OPENSSH|PRIVATE) KEY-----', ] for i, r in enumerate(records): text = json.dumps(r) for pat in cred_patterns: if re.search(pat, text): print(f"❌ CREDENTIAL FOUND in record {i}, pattern: {pat[:30]}") return False return True def main(): args = parse_args() print("=" * 60) print("Qwen 1.5B Fine-Tuning via Unsloth QLoRA") print("=" * 60) print(f"Model: {args.model_name}") print(f"Train file: {args.train_file}") print(f"Eval file: {args.eval_file}") print(f"Output: {args.output_dir}") print(f"LoRA r={args.lora_r} alpha={args.lora_alpha}") print(f"Batch={args.batch_size} grad_acc={args.gradient_accumulation}") print(f"LR={args.learning_rate} epochs={args.num_epochs}") print(f"Max length: {args.max_seq_length}") print("") # ── GPU check ── if torch.cuda.is_available(): print(f"GPU: {torch.cuda.get_device_name(0)}") print(f"VRAM: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.1f} GiB") else: print("WARNING: No GPU detected!") print("") # ── Load data ── print("Loading data...") train_records = load_jsonl(args.train_file) eval_records = load_jsonl(args.eval_file) print(f" Train: {len(train_records)} records") print(f" Eval: {len(eval_records)} records") # ── Credential scrub check ── print("Verifying data cleanliness...") all_records = train_records + eval_records if not scrub_check(all_records): print("❌ DATA NOT CLEAN — aborting!") sys.exit(1) print("✅ Credential check passed") # ── Format data ── print("Formatting conversations...") train_texts = [] for r in train_records: prompt, response = format_messages_for_training(r) if response: train_texts.append({"prompt": prompt, "response": response}) eval_texts = [] for r in eval_records: prompt, response = format_messages_for_training(r) if response: eval_texts.append({"prompt": prompt, "response": response}) print(f" Train formatted: {len(train_texts)}") print(f" Eval formatted: {len(eval_texts)}") train_dataset = Dataset.from_list(train_texts) eval_dataset = Dataset.from_list(eval_texts) # ── Load model ── print(f"\nLoading base model: {args.model_name}") model, tokenizer = FastLanguageModel.from_pretrained( model_name=args.model_name, max_seq_length=args.max_seq_length, dtype=None, load_in_4bit=True, ) # Setup tokenize function now that tokenizer exists def tokenize_fn(examples): texts = [ p + r + "<|im_end|>" for p, r in zip(examples["prompt"], examples["response"]) ] return tokenizer( texts, truncation=True, padding="max_length", max_length=args.max_seq_length, ) # ── Apply LoRA ── print("Applying LoRA adapters...") target_modules = [ "q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj", ] model = FastLanguageModel.get_peft_model( model, r=args.lora_r, target_modules=target_modules, lora_alpha=args.lora_alpha, lora_dropout=0.05, bias="none", use_gradient_checkpointing=True, random_state=42, ) trainable = sum(p.numel() for p in model.parameters() if p.requires_grad) total = sum(p.numel() for p in model.parameters()) print(f" Trainable params: {trainable:,} / {total:,} ({100*trainable/total:.1f}%)") # ── Tokenize datasets ── print("Tokenizing datasets...") train_dataset = train_dataset.map(tokenize_fn, batched=True) eval_dataset = eval_dataset.map(tokenize_fn, batched=True) # ── Training args ── args_training = TrainingArguments( per_device_train_batch_size=args.batch_size, per_device_eval_batch_size=args.batch_size, gradient_accumulation_steps=args.gradient_accumulation, warmup_steps=args.warmup_steps, num_train_epochs=args.num_epochs, learning_rate=args.learning_rate, fp16=not is_bfloat16_supported(), bf16=is_bfloat16_supported(), logging_steps=20, save_steps=args.save_steps, evaluation_strategy="steps", eval_steps=args.save_steps, output_dir=args.output_dir, optim="adamw_8bit", weight_decay=0.01, lr_scheduler_type="cosine", report_to="none", save_total_limit=2, load_best_model_at_end=True, metric_for_best_model="eval_loss", max_grad_norm=0.3, seed=42, ) # ── Trainer ── trainer = SFTTrainer( model=model, tokenizer=tokenizer, args=args_training, train_dataset=train_dataset, eval_dataset=eval_dataset, max_seq_length=args.max_seq_length, dataset_text_field="prompt", ) # ── Train ── print("\n🚀 Starting training...") start = time.time() trainer.train() elapsed = time.time() - start print(f"\n✅ Training completed in {elapsed/60:.1f} minutes") # ── Save ── os.makedirs(args.output_dir, exist_ok=True) model.save_pretrained(args.output_dir) tokenizer.save_pretrained(args.output_dir) print(f"Adapter saved to {args.output_dir}") # ── Provenance ── prov = { "model": args.model_name, "output_dir": args.output_dir, "train_records": len(train_records), "eval_records": len(eval_records), "train_formatted": len(train_texts), "eval_formatted": len(eval_texts), "epochs": args.num_epochs, "batch_size": args.batch_size, "gradient_accumulation": args.gradient_accumulation, "learning_rate": args.learning_rate, "lora_r": args.lora_r, "lora_alpha": args.lora_alpha, "max_seq_length": args.max_seq_length, "training_minutes": round(elapsed / 60, 1), "trainable_params": trainable, "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S"), } with open(os.path.join(args.output_dir, "training_provenance.json"), "w") as f: json.dump(prov, f, indent=2) print("\nProvenance saved.") print("-" * 40) print(f"Adapter: {args.output_dir}/") print(f"Test: python3 -c \"from unsloth import FastLanguageModel; model, tokenizer = FastLanguageModel.from_pretrained('{args.output_dir}'); print('Loaded')\"") print() if __name__ == "__main__": main()