Download train_qwen15b_coder.py from CertainLogicAI/orchestrator-train-mix: direct link, hf CLI and curl.
- Browser
- Download file 9.83 kB
-
https://huggingface.co/datasets/CertainLogicAI/orchestrator-train-mix/resolve/main/train_qwen15b_coder.py
- Command line
-
hf download hf://datasets/CertainLogicAI/orchestrator-train-mix/train_qwen15b_coder.py
-
curl -L -o train_qwen15b_coder.py https://huggingface.co/datasets/CertainLogicAI/orchestrator-train-mix/resolve/main/train_qwen15b_coder.py
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() |