scripts: add scripts/train_sft_completion_only.py

scripts/train_sft_completion_only.py

@@ -0,0 +1,130 @@
+"""
+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()