train_lora.py

#!/usr/bin/env python3
"""
Universal LoRA training script for RunPod.
Runs on the pod itself. Configured via environment variables.

Usage:
  MODEL_NAME=Qwen/Qwen2.5-7B-Instruct NUM_EPOCHS=3 LORA_R=64 python train_lora.py
"""
import os
import sys
import json
import torch
from datetime import datetime

# Shim for DeepSeek-V3 compat: older model code references a removed transformers API
import transformers.utils.import_utils as _tiu
if not hasattr(_tiu, "is_torch_fx_available"):
    _tiu.is_torch_fx_available = lambda: False

# ============================================================
# Configuration from environment
# ============================================================
MODEL_NAME = os.environ.get("MODEL_NAME", "Qwen/Qwen2.5-7B-Instruct")
HF_TOKEN = os.environ.get("HF_TOKEN", "")
DATASET_REPO = os.environ.get("DATASET_REPO", "oridror/metaverse-expert-training-data")
OUTPUT_REPO = os.environ.get("OUTPUT_REPO", "")  # If set, push to HF Hub
OUTPUT_DIR = os.environ.get("OUTPUT_DIR", "/workspace/output")

# LoRA config
LORA_R = int(os.environ.get("LORA_R", "64"))
LORA_ALPHA = int(os.environ.get("LORA_ALPHA", "128"))
LORA_DROPOUT = float(os.environ.get("LORA_DROPOUT", "0.05"))

# Training config
NUM_EPOCHS = int(os.environ.get("NUM_EPOCHS", "3"))
BATCH_SIZE = int(os.environ.get("BATCH_SIZE", "4"))
GRAD_ACCUM = int(os.environ.get("GRAD_ACCUM", "4"))
LR = float(os.environ.get("LR", "5e-5"))
MAX_SEQ_LEN = int(os.environ.get("MAX_SEQ_LEN", "4096"))
USE_4BIT = os.environ.get("USE_4BIT", "false").lower() == "true"

# Target modules per architecture
QWEN_MODULES = ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
DEEPSEEK_MODULES = ["q_a_proj", "q_b_proj", "kv_a_proj_with_mqa", "kv_b_proj",
                     "mlp.gate_proj", "mlp.up_proj", "mlp.down_proj"]

def get_target_modules(model_name):
    lower = model_name.lower()
    if "deepseek" in lower:
        return DEEPSEEK_MODULES
    return QWEN_MODULES

# ============================================================
# Main
# ============================================================
def main():
    print("=" * 70)
    print(f"METAVERSE EXPERT — LoRA Training")
    print(f"Model: {MODEL_NAME}")
    print(f"Epochs: {NUM_EPOCHS} | Batch: {BATCH_SIZE} | Grad Accum: {GRAD_ACCUM}")
    print(f"LoRA r={LORA_R} alpha={LORA_ALPHA}")
    print(f"4-bit: {USE_4BIT} | Max Seq Len: {MAX_SEQ_LEN}")
    print(f"GPUs: {torch.cuda.device_count()}")
    for i in range(torch.cuda.device_count()):
        print(f"  GPU {i}: {torch.cuda.get_device_name(i)} — {torch.cuda.get_device_properties(i).total_memory / 1e9:.1f} GB")
    print(f"Started: {datetime.now().isoformat()}")
    print("=" * 70)

    # Import after config
    from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig, TrainingArguments
    from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
    from trl import SFTTrainer, SFTConfig
    from datasets import load_dataset

    # ---- Load dataset ----
    print("\n📦 Loading dataset...")
    ds = load_dataset(DATASET_REPO, token=HF_TOKEN)
    train_ds = ds["train"] if "train" in ds else load_dataset(DATASET_REPO, data_files="train.jsonl", split="train", token=HF_TOKEN)
    valid_ds = ds.get("validation") or load_dataset(DATASET_REPO, data_files="valid.jsonl", split="train", token=HF_TOKEN)
    print(f"  Train: {len(train_ds)} examples")
    print(f"  Valid: {len(valid_ds)} examples")

    # ---- Load tokenizer ----
    print("\n📝 Loading tokenizer...")
    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, token=HF_TOKEN, trust_remote_code=True)
    if tokenizer.pad_token is None:
        tokenizer.pad_token = tokenizer.eos_token

    # ---- Load model ----
    print(f"\n🧠 Loading model: {MODEL_NAME}...")
    model_kwargs = {
        "token": HF_TOKEN,
        "trust_remote_code": True,
        "torch_dtype": torch.bfloat16,
        "attn_implementation": "flash_attention_2",
    }

    if USE_4BIT and "deepseek" not in MODEL_NAME.lower():
        print("  Using 4-bit quantization (QLoRA)")
        bnb_config = BitsAndBytesConfig(
            load_in_4bit=True,
            bnb_4bit_quant_type="nf4",
            bnb_4bit_compute_dtype=torch.bfloat16,
            bnb_4bit_use_double_quant=True,
        )
        model_kwargs["quantization_config"] = bnb_config
    else:
        # For multi-GPU, use device_map auto
        if torch.cuda.device_count() > 1:
            model_kwargs["device_map"] = "auto"
        else:
            model_kwargs["device_map"] = {"": 0}

    model = AutoModelForCausalLM.from_pretrained(MODEL_NAME, **model_kwargs)

    # prepare_model_for_kbit_training removed — peft 0.18+ uses set_submodule
    # which requires PyTorch 2.5+, but RunPod image has 2.4. SFTTrainer handles it.

    # ---- LoRA config ----
    target_modules = get_target_modules(MODEL_NAME)
    print(f"\n🔧 LoRA config: r={LORA_R}, alpha={LORA_ALPHA}, targets={target_modules}")

    lora_config = LoraConfig(
        r=LORA_R,
        lora_alpha=LORA_ALPHA,
        lora_dropout=LORA_DROPOUT,
        target_modules=target_modules,
        bias="none",
        task_type="CAUSAL_LM",
    )

    model = get_peft_model(model, lora_config)
    model.print_trainable_parameters()

    # ---- Format function for chat messages ----
    def format_chat(example):
        text = tokenizer.apply_chat_template(
            example["messages"],
            tokenize=False,
            add_generation_prompt=False,
        )
        return {"text": text}

    print("\n🔄 Formatting dataset...")
    train_ds = train_ds.map(format_chat, num_proc=4, remove_columns=train_ds.column_names)
    valid_ds = valid_ds.map(format_chat, num_proc=4, remove_columns=valid_ds.column_names)

    # ---- Training args ----
    model_short = MODEL_NAME.split("/")[-1]
    run_name = f"metaverse-expert-{model_short}"

    effective_batch = BATCH_SIZE * GRAD_ACCUM * max(1, torch.cuda.device_count())
    total_steps = (len(train_ds) * NUM_EPOCHS) // effective_batch
    save_steps = max(total_steps // 10, 50)  # Save ~10 checkpoints
    eval_steps = save_steps

    print(f"\n📊 Training plan:")
    print(f"  Effective batch size: {effective_batch}")
    print(f"  Total steps: {total_steps}")
    print(f"  Save every: {save_steps} steps")

    training_args = SFTConfig(
        output_dir=OUTPUT_DIR,
        run_name=run_name,
        num_train_epochs=NUM_EPOCHS,
        per_device_train_batch_size=BATCH_SIZE,
        per_device_eval_batch_size=BATCH_SIZE,
        gradient_accumulation_steps=GRAD_ACCUM,
        learning_rate=LR,
        lr_scheduler_type="cosine",
        warmup_ratio=0.03,
        weight_decay=0.01,
        bf16=True,
        logging_steps=10,
        save_steps=save_steps,
        eval_strategy="steps",
        eval_steps=eval_steps,
        save_total_limit=3,
        max_length=MAX_SEQ_LEN,
        packing=True,  # Pack short sequences for efficiency
        gradient_checkpointing=True,
        gradient_checkpointing_kwargs={"use_reentrant": False},
        report_to="none",
        max_grad_norm=1.0,
    )

    # ---- Train ----
    print("\n🚀 Starting training...")
    trainer = SFTTrainer(
        model=model,
        args=training_args,
        train_dataset=train_ds,
        eval_dataset=valid_ds,
    )

    trainer.train()

    # ---- Save ----
    print("\n💾 Saving model...")
    trainer.save_model(OUTPUT_DIR)
    tokenizer.save_pretrained(OUTPUT_DIR)

    # Push to HF Hub if configured
    if OUTPUT_REPO:
        print(f"\n📤 Pushing to HF Hub: {OUTPUT_REPO}")
        trainer.push_to_hub(OUTPUT_REPO, token=HF_TOKEN, private=True)

    print(f"\n✅ Training complete! {datetime.now().isoformat()}")
    print(f"Model saved to: {OUTPUT_DIR}")

    # Write completion marker
    with open(os.path.join(OUTPUT_DIR, "TRAINING_COMPLETE"), "w") as f:
        f.write(f"Completed: {datetime.now().isoformat()}\nModel: {MODEL_NAME}\n")

if __name__ == "__main__":
    main()