HVU_QA

HVU_QA/fine_tune_qg.py

@@ -1,153 +1,125 @@
-import re
-import torch
-from difflib import SequenceMatcher
-from transformers import T5Tokenizer, T5ForConditionalGeneration
-from transformers.utils import logging as hf_logging
-
-hf_logging.set_verbosity_error()
-
-MODEL_DIR = "t5-viet-qg-finetuned"
-
-PATTERN = re.compile(
-    r"""
-    “([^”]{3,120})”
-  | "([^"]{3,120})"
-  | \b(?:là|gồm|do|theo)\s+([^,.;:\n]{3,120})
-  | \b\d{4}\b
-  | \b(?:Điều|Khoản)\s+\d+\b
-    """,
-    re.VERBOSE | re.IGNORECASE,
-)
-
-
-def norm(s: str) -> str:
-    return re.sub(r"\s+", " ", s).strip()
-
-
-def is_dup(q: str, qs: list[str], thr: float = 0.85) -> bool:
-    ql = q.lower()
-    for x in qs:
-        if SequenceMatcher(None, ql, x.lower()).ratio() >= thr:
-            return True
-    return False
-
-
-def extract_answers(ctx: str, max_n: int = 60) -> list[str]:
-    ctx = norm(ctx)
-    answers, seen = [], set()
-
-    for m in PATTERN.finditer(ctx):
-        for g in m.groups():
-            if not g:
-                continue
-            g = norm(g)
-            k = g.lower()
-            if 3 <= len(g) <= 120 and k not in seen:
-                seen.add(k)
-                answers.append(g)
-                if len(answers) >= max_n:
-                    return answers
-
-    if len(answers) < 8:
-        for i in range(0, min(len(ctx), 500), 60):
-            ch = norm(ctx[i : i + 60])
-            k = ch.lower()
-            if len(ch) >= 15 and k not in seen:
-                seen.add(k)
-                answers.append(ch)
-            if len(answers) >= max_n:
-                break
-
-    if not answers and ctx:
-        answers = [ctx[:120]]
-
-    return answers
-
-
-def load_model():
-    tok = T5Tokenizer.from_pretrained(MODEL_DIR)
-    mdl = T5ForConditionalGeneration.from_pretrained(MODEL_DIR)
-
-    dev = "cuda" if torch.cuda.is_available() else "cpu"
-    try:
-        mdl = mdl.to(dev)
-    except RuntimeError:
-        dev = "cpu"
-        try:
-            torch.cuda.empty_cache()
-        except Exception:
-            pass
-        mdl = mdl.to(dev)
-
-    mdl.eval()
-    return tok, mdl, dev
+import os, json
+from datasets import Dataset
+from sklearn.model_selection import train_test_split
+from transformers import T5Tokenizer, T5ForConditionalGeneration, TrainingArguments, Trainer, DataCollatorForSeq2Seq
+
+
+def load_squad(path: str):
+    with open(path, "r", encoding="utf-8") as f:
+        d = json.load(f)
+
+    data = []
+    for a in d.get("data", []):
+        for p in a.get("paragraphs", []):
+            ctx = p.get("context", "")
+            for qa in p.get("qas", []):
+                if qa.get("is_impossible") or not qa.get("answers"):
+                    continue
+                ans = qa["answers"][0].get("text", "")
+                q = qa.get("question", "")
+                if ans and q and ctx:
+                    data.append({"input": f"answer: {ans} context: {ctx}", "target": q})
+    return data
 
 
-tokenizer, model, device = load_model()
+def tokenize(batch, tok, max_in=512, max_out=64):
+    x = tok(batch["input"], max_length=max_in, truncation=True)
+    y = tok(text_target=batch["target"], max_length=max_out, truncation=True)
+    x["labels"] = y["input_ids"]
+    return x
 
 
-def generate_questions(context: str, n: int = 20) -> list[str]:
-    ctx = norm(context)
-    answers = extract_answers(ctx, max_n=80)
-    questions = []
+def latest_ckpt(out_dir: str):
+    if not os.path.isdir(out_dir):
+        return None
 
-    gen_cfg = dict(
-        do_sample=True,
-        top_k=80,
-        top_p=0.98,
-        temperature=1.05,
-        max_new_tokens=72,
-        no_repeat_ngram_size=3,
-        repetition_penalty=1.08,
+    best_step, best_path = -1, None
+    for name in os.listdir(out_dir):
+        if not name.startswith("checkpoint-"):
+            continue
+        try:
+            step = int(name.split("-")[-1])
+        except ValueError:
+            continue
+        if step > best_step:
+            best_step, best_path = step, os.path.join(out_dir, name)
+
+    return best_path
+
+
+def main():
+    data_path = "39k_train.json"
+    out_dir = "t5-viet-qg-finetuned"
+    logs_dir = "logs"
+    model_name = "VietAI/vit5-base"
+
+    print("Tải mô hình và tokenizer...")
+    tok = T5Tokenizer.from_pretrained(model_name)
+    model = T5ForConditionalGeneration.from_pretrained(model_name)
+
+    print("Đọc và chia dữ liệu...")
+    data = load_squad(data_path)
+    tr, va = train_test_split(data, test_size=0.2, random_state=42)
+
+    print("Tokenize dữ liệu...")
+    tr_ds = Dataset.from_list(tr).map(
+        lambda b: tokenize(b, tok),
+        batched=True,
+        remove_columns=["input", "target"],
+    )
+    va_ds = Dataset.from_list(va).map(
+        lambda b: tokenize(b, tok),
+        batched=True,
+        remove_columns=["input", "target"],
     )
 
-    num_ret = 8 if n <= 20 else 10
-
-    def run_prompt(ans: str, rounds: int):
-        nonlocal gen_cfg
-        prompt = f"answer: {ans}\ncontext: {ctx}\nquestion:"
-        inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512).to(device)
+    print("Cấu hình huấn luyện (checkpoint + resume)...")
+    args = TrainingArguments(
+        output_dir=out_dir,
+        overwrite_output_dir=False,
+        per_device_train_batch_size=1,
+        gradient_accumulation_steps=1,
+        num_train_epochs=3,
+        learning_rate=2e-4,
+        weight_decay=0.01,
+        warmup_steps=0,
+        save_strategy="steps",
+        save_steps=500,
+        save_total_limit=100,
+        eval_strategy="steps",
+        eval_steps=500,
+        load_best_model_at_end=True,
+        metric_for_best_model="eval_loss",
+        greater_is_better=False,
+        logging_dir=logs_dir,
+        logging_steps=10,
+        fp16=True,
+        report_to="none",
+    )
 
-        for _ in range(rounds):
-            outs = model.generate(**inputs, num_return_sequences=num_ret, **gen_cfg)
-            added = 0
-            for o in outs:
-                q = norm(tokenizer.decode(o, skip_special_tokens=True))
-                if not q:
-                    continue
-                if not q.endswith("?"):
-                    q += "?"
-                if len(q) >= 6 and not is_dup(q, questions, thr=0.85):
-                    questions.append(q)
-                    added += 1
-                if len(questions) >= n:
-                    return
-            if added == 0:
-                gen_cfg["temperature"] = min(1.25, gen_cfg["temperature"] + 0.05)
-                gen_cfg["top_p"] = min(0.995, gen_cfg["top_p"] + 0.005)
+    trainer = Trainer(
+        model=model,
+        args=args,
+        train_dataset=tr_ds,
+        eval_dataset=va_ds,
+        tokenizer=tok,
+        data_collator=DataCollatorForSeq2Seq(tokenizer=tok, model=model),
+    )
 
-    with torch.inference_mode():
-        for ans in answers:
-            if len(questions) >= n:
-                break
-            run_prompt(ans, rounds=6)
+    ckpt = latest_ckpt(out_dir)
+    if ckpt:
+        print(f"Phát hiện checkpoint: {ckpt} → Resume training")
+        trainer.train(resume_from_checkpoint=ckpt)
+    else:
+        print("Không có checkpoint → Train từ đầu")
+        trainer.train()
 
-        if len(questions) < n:
-            run_prompt(ctx[:120], rounds=12)
+    print("Lưu mô hình cuối cùng...")
+    trainer.save_model(out_dir)
+    tok.save_pretrained(out_dir)
 
-    return questions[:n]
+    print("Huấn luyện hoàn tất!")
 
 
 if __name__ == "__main__":
-    ctx = input("\nNhập đoạn văn bản:\n").strip()
-    try:
-        n = int((input("\nNhập số lượng câu hỏi cần sinh: ").strip() or "20"))
-    except ValueError:
-        n = 20
-
-    n = max(1, min(n, 200))
-    qs = generate_questions(ctx, n)
-
-    print("\nCác câu hỏi sinh ra:")
-    for i, q in enumerate(qs, 1):
-        print(f"{i}. {q}")
+    main()