scripts/train_sft_completion_only.py

"""
SFT trainer with COMPLETION-ONLY loss (per MATS paper §3.6).
Handles HF datasets with 'prompt' + 'completion' columns.
Uses Qwen chat template; masks prompt tokens with -100 in labels.
"""
import argparse, os
os.environ.setdefault("PYTHONNOUSERSITE", "1")

import torch
from datasets import load_from_disk
from transformers import (
    AutoModelForCausalLM, AutoTokenizer, Trainer, TrainingArguments,
    DataCollatorForSeq2Seq,
)


CHAT_TEMPLATES = {
    "qwen": {
        "user_head": "<|im_start|>user\n",
        "user_tail": "<|im_end|>\n",
        "asst_head": "<|im_start|>assistant\n",
        "asst_tail": "<|im_end|>",
    },
    "llama3": {
        "user_head": "<|begin_of_text|><|start_header_id|>user<|end_header_id|>\n\n",
        "user_tail": "<|eot_id|>",
        "asst_head": "<|start_header_id|>assistant<|end_header_id|>\n\n",
        "asst_tail": "<|eot_id|>",
    },
}


def main():
    p = argparse.ArgumentParser()
    p.add_argument("--base", required=True)
    p.add_argument("--data", required=True)
    p.add_argument("--out", required=True)
    p.add_argument("--epochs", type=float, default=4.0)
    p.add_argument("--lr", type=float, default=2e-5)
    p.add_argument("--bs", type=int, default=1)
    p.add_argument("--grad_accum", type=int, default=16)
    p.add_argument("--max_len", type=int, default=6144)
    p.add_argument("--warmup", type=float, default=0.05)
    p.add_argument("--chat_format", default="qwen", choices=["qwen", "llama3"])
    args = p.parse_args()

    print(f"loading base={args.base}", flush=True)
    tok = AutoTokenizer.from_pretrained(args.base, trust_remote_code=True,
        cache_dir="/weka/s225250685/Huggingface/hub")
    if tok.pad_token is None:
        tok.pad_token = tok.eos_token

    model = AutoModelForCausalLM.from_pretrained(
        args.base, torch_dtype=torch.bfloat16, trust_remote_code=True,
        attn_implementation="sdpa",
        cache_dir="/weka/s225250685/Huggingface/hub",
    )

    print(f"loading data={args.data}", flush=True)
    dd = load_from_disk(args.data)
    print(f"train={len(dd['train'])} test={len(dd['test'])}", flush=True)

    tpl = CHAT_TEMPLATES[args.chat_format]
    USER_HEAD = tpl["user_head"]
    USER_TAIL = tpl["user_tail"]
    ASSISTANT_HEAD = tpl["asst_head"]
    ASSISTANT_TAIL = tpl["asst_tail"]
    print(f"chat_format={args.chat_format}", flush=True)

    def encode(ex):
        prompt_text = f"{USER_HEAD}{ex['prompt']}{USER_TAIL}{ASSISTANT_HEAD}"
        completion_text = f"{ex['completion']}{ASSISTANT_TAIL}"
        full_text = prompt_text + completion_text

        # Tokenize full
        full_ids = tok(full_text, truncation=True, max_length=args.max_len,
                       padding=False, add_special_tokens=False)["input_ids"]
        # Tokenize prompt-only (to find length for label masking)
        prompt_ids = tok(prompt_text, truncation=True, max_length=args.max_len,
                         padding=False, add_special_tokens=False)["input_ids"]
        prompt_len = len(prompt_ids)

        # Build labels: -100 for prompt, real ids for completion
        labels = [-100] * prompt_len + full_ids[prompt_len:]
        labels = labels[:len(full_ids)]
        attention = [1] * len(full_ids)

        return {"input_ids": full_ids, "attention_mask": attention, "labels": labels}

    print("Tokenizing...", flush=True)
    train_ds = dd["train"].map(encode, remove_columns=dd["train"].column_names, num_proc=4)
    eval_ds  = dd["test"].map(encode,  remove_columns=dd["test"].column_names,  num_proc=4)

    # DataCollatorForSeq2Seq pads input_ids with pad_token and labels with -100
    collator = DataCollatorForSeq2Seq(tok, padding=True, label_pad_token_id=-100)

    targs = TrainingArguments(
        output_dir=args.out,
        num_train_epochs=args.epochs,
        per_device_train_batch_size=args.bs,
        per_device_eval_batch_size=args.bs,
        gradient_accumulation_steps=args.grad_accum,
        learning_rate=args.lr,
        warmup_ratio=args.warmup,
        lr_scheduler_type="cosine",
        bf16=True,
        logging_steps=20,
        save_strategy="epoch",
        eval_strategy="epoch",
        save_total_limit=1,
        report_to=[],
        gradient_checkpointing=True,
        gradient_checkpointing_kwargs={"use_reentrant": False},
        remove_unused_columns=False,
        dataloader_num_workers=2,
    )

    trainer = Trainer(
        model=model, args=targs,
        train_dataset=train_ds, eval_dataset=eval_ds,
        tokenizer=tok, data_collator=collator,
    )
    trainer.train()
    trainer.save_model(args.out)
    tok.save_pretrained(args.out)
    print(f"SAVED: {args.out}", flush=True)


if __name__ == "__main__":
    main()