orchestrator-train-mix / train_qwen15b_coder.py
CertainLogicAI's picture
Upload train_qwen15b_coder.py with huggingface_hub
fb0e14f verified
Raw History Blame Contribute Delete
9.83 kB
#!/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()