Datasets:

oridror
/

metaverse-expert-training-data

#!/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()

	#!/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()