Update

HVU_QA/fine_tune_qg.py

@@ -0,0 +1,556 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+from importlib import metadata
+from inspect import signature
+from pathlib import Path
+from typing import Any
+
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
+
+
+def raise_missing_dependency_error(exc: ModuleNotFoundError) -> None:
+    root = Path(__file__).resolve().parent
+    script = Path(__file__).resolve()
+    requirements = root / "requirements.txt"
+    venv_python = root / "venv" / ("Scripts/python.exe" if os.name == "nt" else "bin/python")
+    lines = [f"Thiếu thư viện Python: {exc.name}", f"Interpreter hiện tại: {sys.executable}"]
+    if venv_python.exists():
+        lines.extend([f"Venv của project: {venv_python}", f"Chạy lại bằng: {venv_python} {script}"])
+    if requirements.exists():
+        lines.extend(
+            [
+                "Hoặc cài dependencies cho interpreter hiện tại bằng:",
+                f"{sys.executable} -m pip install -r {requirements}",
+            ]
+        )
+    raise SystemExit("\n".join(lines)) from exc
+
+
+try:
+    import torch
+    from datasets import Dataset
+    from transformers import (
+        AutoModelForSeq2SeqLM,
+        AutoTokenizer,
+        DataCollatorForSeq2Seq,
+        EarlyStoppingCallback,
+        Seq2SeqTrainer,
+        Seq2SeqTrainingArguments,
+        set_seed,
+    )
+    from transformers.trainer_utils import get_last_checkpoint
+except ModuleNotFoundError as exc:
+    raise_missing_dependency_error(exc)
+
+
+def normalize_text(text: Any) -> str:
+    return " ".join(str(text or "").split())
+
+
+def dedupe(items) -> list[str]:
+    seen, output = set(), []
+    for item in items:
+        if item and item not in seen:
+            seen.add(item)
+            output.append(item)
+    return output
+
+
+def save_json(data: dict[str, Any], path: Path) -> None:
+    path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+def get_installed_version(package_name: str) -> tuple[int, ...]:
+    try:
+        version = metadata.version(package_name)
+    except metadata.PackageNotFoundError:
+        return ()
+
+    parts = []
+    for chunk in version.replace("-", ".").split("."):
+        digits = "".join(ch for ch in chunk if ch.isdigit())
+        if not digits:
+            break
+        parts.append(int(digits))
+    return tuple(parts)
+
+
+def supports_data_seed() -> bool:
+    return get_installed_version("accelerate") >= (1, 1, 0)
+
+
+def run_nvidia_smi(query: str) -> list[list[str]]:
+    try:
+        result = subprocess.run(
+            ["nvidia-smi", f"--query-{query}", "--format=csv,noheader,nounits"],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        return []
+
+    return [
+        [part.strip() for part in line.split(",")]
+        for line in result.stdout.strip().splitlines()
+        if line.strip()
+    ]
+
+
+def query_gpu_memory():
+    rows = run_nvidia_smi("gpu=memory.total,memory.used,memory.free")
+    if not rows or len(rows[0]) < 3:
+        return None
+    try:
+        total_mb, used_mb, free_mb = (int(value) for value in rows[0][:3])
+    except ValueError:
+        return None
+    return {"total_mb": total_mb, "used_mb": used_mb, "free_mb": free_mb}
+
+
+def query_gpu_processes() -> list[dict[str, Any]]:
+    processes = []
+    for row in run_nvidia_smi("compute-apps=pid,process_name,used_memory"):
+        if len(row) != 3:
+            continue
+        try:
+            pid = int(row[0])
+            used_memory_mb = int(row[2])
+        except ValueError:
+            continue
+        processes.append({"pid": pid, "process_name": row[1], "used_memory_mb": used_memory_mb})
+    return processes
+
+
+def format_memory_mb(memory_mb: int) -> str:
+    return f"{memory_mb} MiB ({memory_mb / 1024:.2f} GiB)"
+
+
+def active_gpu_processes() -> list[dict[str, Any]]:
+    current_pid = os.getpid()
+    return sorted(
+        [proc for proc in query_gpu_processes() if proc["pid"] != current_pid and proc["used_memory_mb"] > 0],
+        key=lambda item: item["used_memory_mb"],
+        reverse=True,
+    )
+
+
+def append_process_lines(lines: list[str], header: str, processes: list[dict[str, Any]]) -> None:
+    if not processes:
+        return
+    lines.append(header)
+    lines.extend(
+        f"- PID {proc['pid']} | {proc['process_name']} | {format_memory_mb(proc['used_memory_mb'])}"
+        for proc in processes
+    )
+
+
+def ensure_device_ready(args) -> None:
+    if args.device == "cpu":
+        return
+    if not torch.cuda.is_available():
+        if args.device == "cuda":
+            raise SystemExit("Bạn đã chọn --device cuda nhưng môi trường hiện tại không có CUDA.")
+        return
+    if args.skip_gpu_preflight:
+        return
+
+    gpu_memory = query_gpu_memory()
+    if gpu_memory is None or gpu_memory["free_mb"] >= args.min_free_gpu_mb:
+        return
+
+    lines = [
+        "GPU không đủ bộ nhớ để bắt đầu train ổn định.",
+        f"GPU free: {format_memory_mb(gpu_memory['free_mb'])} / total: {format_memory_mb(gpu_memory['total_mb'])}.",
+        f"Ngưỡng tối thiểu hiện tại: {format_memory_mb(args.min_free_gpu_mb)}.",
+    ]
+    append_process_lines(lines, "Các tiến trình CUDA đang chiếm GPU:", active_gpu_processes())
+    lines.extend(
+        [
+            "Cách xử lý:",
+            "- Giải phóng tiến trình đang chiếm GPU rồi chạy lại.",
+            "- Hoặc train trên CPU bằng `python fine_tune_qg.py --device cpu`.",
+            "- Nếu GPU đã rảnh mà vẫn thiếu VRAM, thử `--per_device_train_batch_size 1 --per_device_eval_batch_size 1 --gradient_accumulation_steps 16 --gradient_checkpointing`.",
+            "- Nếu bạn vẫn muốn thử trên GPU hiện tại, thêm `--skip_gpu_preflight` để bỏ qua kiểm tra này.",
+        ]
+    )
+    raise SystemExit("\n".join(lines))
+
+
+def raise_cuda_oom(args) -> None:
+    gpu_memory = query_gpu_memory()
+    lines = ["Train thất bại do CUDA out of memory."]
+    if gpu_memory is not None:
+        lines.append(
+            f"VRAM hiện tại: free {format_memory_mb(gpu_memory['free_mb'])}, used {format_memory_mb(gpu_memory['used_mb'])}, total {format_memory_mb(gpu_memory['total_mb'])}."
+        )
+    append_process_lines(lines, "Các tiến trình khác đang dùng GPU:", active_gpu_processes())
+    lines.extend(
+        [
+            "Gợi ý:",
+            "- Dừng tiến trình CUDA khác rồi chạy lại.",
+            f"- Hoặc chạy trên CPU: python fine_tune_qg.py --device cpu --output_dir {args.output_dir}-cpu",
+            "- Khi GPU rảnh, nếu vẫn thiếu VRAM, giảm batch: `--per_device_train_batch_size 1 --per_device_eval_batch_size 1 --gradient_accumulation_steps 16 --gradient_checkpointing`.",
+        ]
+    )
+    raise SystemExit("\n".join(lines))
+
+
+def build_source(title: str, context: str, answer: str, task_prefix: str) -> str:
+    parts = [f"{task_prefix}:"]
+    if title:
+        parts.append(f"tiêu đề: {title}")
+    parts.extend((f"ngữ cảnh: {context}", f"đáp án: {answer}"))
+    return "\n".join(parts)
+
+
+def load_squad_qg_examples(
+    file_path: str,
+    use_all_answers: bool = True,
+    task_prefix: str = "sinh câu hỏi",
+    require_answer_in_context: bool = False,
+) -> tuple[list[dict[str, str]], dict[str, int]]:
+    data = json.loads(Path(file_path).read_text(encoding="utf-8"))
+    examples = []
+    stats = {
+        "articles": 0,
+        "paragraphs": 0,
+        "qas": 0,
+        "examples": 0,
+        "skipped_impossible": 0,
+        "skipped_no_context": 0,
+        "skipped_no_question": 0,
+        "skipped_no_answers": 0,
+        "skipped_answer_not_in_context": 0,
+        "answers_not_in_context_but_kept": 0,
+    }
+
+    for article in data.get("data", []):
+        stats["articles"] += 1
+        title = normalize_text(article.get("title"))
+        for paragraph in article.get("paragraphs", []):
+            stats["paragraphs"] += 1
+            context = normalize_text(paragraph.get("context"))
+            if not context:
+                stats["skipped_no_context"] += 1
+                continue
+
+            for qa in paragraph.get("qas", []):
+                stats["qas"] += 1
+                question = normalize_text(qa.get("question"))
+                if qa.get("is_impossible", False):
+                    stats["skipped_impossible"] += 1
+                    continue
+                if not question:
+                    stats["skipped_no_question"] += 1
+                    continue
+
+                answers = dedupe(normalize_text(answer.get("text")) for answer in qa.get("answers", []))
+                if not answers:
+                    stats["skipped_no_answers"] += 1
+                    continue
+                if not use_all_answers:
+                    answers = answers[:1]
+
+                for answer in answers:
+                    in_context = answer in context
+                    if require_answer_in_context and not in_context:
+                        stats["skipped_answer_not_in_context"] += 1
+                        continue
+                    if not in_context:
+                        stats["answers_not_in_context_but_kept"] += 1
+
+                    examples.append(
+                        {
+                            "source": build_source(title, context, answer, task_prefix),
+                            "target": question,
+                        }
+                    )
+                    stats["examples"] += 1
+
+    return examples, stats
+
+
+def preprocess_function(batch, tokenizer, max_source_length: int, max_target_length: int) -> dict[str, Any]:
+    model_inputs = tokenizer(batch["source"], max_length=max_source_length, truncation=True)
+    model_inputs["labels"] = tokenizer(
+        text_target=batch["target"],
+        max_length=max_target_length,
+        truncation=True,
+    )["input_ids"]
+    return model_inputs
+
+
+def build_supported_kwargs(cls, kwargs: dict[str, Any], aliases=None) -> dict[str, Any]:
+    params = set(signature(cls.__init__).parameters)
+    aliases = aliases or {}
+    resolved = {}
+    for key, value in kwargs.items():
+        if value is None:
+            continue
+        target = key if key in params else aliases.get(key)
+        if target in params:
+            resolved[target] = value
+    return resolved
+
+
+def build_training_args(args, has_eval: bool):
+    kwargs = {
+        "output_dir": args.output_dir,
+        "overwrite_output_dir": False,
+        "learning_rate": args.learning_rate,
+        "per_device_train_batch_size": args.per_device_train_batch_size,
+        "per_device_eval_batch_size": args.per_device_eval_batch_size,
+        "gradient_accumulation_steps": args.gradient_accumulation_steps,
+        "weight_decay": args.weight_decay,
+        "num_train_epochs": args.num_train_epochs,
+        "warmup_ratio": args.warmup_ratio,
+        "logging_strategy": "steps",
+        "logging_steps": args.logging_steps,
+        "save_strategy": args.save_strategy_type,
+        "save_steps": args.save_steps if args.save_strategy_type == "steps" else None,
+        "save_total_limit": args.save_total_limit,
+        "report_to": "none",
+        "fp16": args.fp16,
+        "bf16": args.bf16,
+        "predict_with_generate": False,
+        "generation_max_length": args.max_target_length,
+        "dataloader_num_workers": args.dataloader_num_workers,
+        "dataloader_pin_memory": not args.no_pin_memory,
+        "save_only_model": args.save_only_model,
+        "restore_callback_states_from_checkpoint": args.restore_callback_states_from_checkpoint,
+        "torch_empty_cache_steps": args.torch_empty_cache_steps or None,
+        "seed": args.seed,
+        "data_seed": args.seed if supports_data_seed() else None,
+        "use_cpu": True if args.device == "cpu" else None,
+        "gradient_checkpointing": True if args.gradient_checkpointing else None,
+        "load_best_model_at_end": has_eval,
+        "metric_for_best_model": "eval_loss" if has_eval else None,
+        "greater_is_better": False if has_eval else None,
+        "eval_strategy": args.save_strategy_type if has_eval else None,
+        "eval_steps": args.eval_steps if has_eval and args.save_strategy_type == "steps" else None,
+    }
+    return Seq2SeqTrainingArguments(
+        **build_supported_kwargs(
+            Seq2SeqTrainingArguments,
+            kwargs,
+            aliases={"eval_strategy": "evaluation_strategy", "use_cpu": "no_cuda"},
+        )
+    )
+
+
+def resolve_resume_checkpoint(args):
+    if args.resume_checkpoint:
+        if not Path(args.resume_checkpoint).is_dir():
+            raise FileNotFoundError(f"Không tìm thấy resume_checkpoint: {args.resume_checkpoint}")
+        return args.resume_checkpoint
+    if args.resume_from_latest and Path(args.output_dir).is_dir():
+        return get_last_checkpoint(args.output_dir)
+    return None
+
+
+def validate_args(args, has_eval: bool) -> None:
+    if has_eval and args.save_strategy_type == "steps":
+        if args.eval_steps <= 0 or args.save_steps <= 0:
+            raise ValueError("save_steps và eval_steps phải > 0")
+        if args.save_steps % args.eval_steps != 0:
+            raise ValueError("save_steps phải là bội số của eval_steps")
+    if args.save_only_model and (args.resume_from_latest or args.resume_checkpoint):
+        print("Cảnh báo: save_only_model sẽ không resume train đầy đủ được.")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser()
+    add = parser.add_argument
+
+    add("--train_file", default="40k_train.json")
+    add("--validation_file", default=None)
+    add("--output_dir", default="t5-viet-qg-finetuned")
+    add("--model_name", default="VietAI/vit5-base")
+    add("--task_prefix", default="sinh câu hỏi")
+
+    add("--max_source_length", type=int, default=512)
+    add("--max_target_length", type=int, default=64)
+    add("--val_ratio", type=float, default=0.1)
+
+    add("--per_device_train_batch_size", type=int, default=4)
+    add("--per_device_eval_batch_size", type=int, default=4)
+    add("--gradient_accumulation_steps", type=int, default=4)
+    add("--learning_rate", type=float, default=1e-4)
+    add("--weight_decay", type=float, default=0.01)
+    add("--warmup_ratio", type=float, default=0.05)
+    add("--num_train_epochs", type=int, default=3)
+    add("--logging_steps", type=int, default=50)
+    add("--seed", type=int, default=42)
+    add("--early_stopping_patience", type=int, default=2)
+
+    add("--save_strategy_type", default="steps", choices=["steps", "epoch"])
+    add("--save_steps", type=int, default=500)
+    add("--eval_steps", type=int, default=500)
+    add("--save_total_limit", type=int, default=1)
+
+    parser.set_defaults(resume_from_latest=True)
+    add("--resume_from_latest", dest="resume_from_latest", action="store_true")
+    add("--no_resume_from_latest", dest="resume_from_latest", action="store_false")
+    add("--resume_checkpoint", default=None)
+    add("--save_only_model", action="store_true")
+    add("--restore_callback_states_from_checkpoint", action="store_true")
+
+    add("--fp16", action="store_true")
+    add("--bf16", action="store_true")
+    add("--gradient_checkpointing", action="store_true")
+    add("--dataloader_num_workers", type=int, default=0)
+    add("--no_pin_memory", action="store_true")
+    add("--torch_empty_cache_steps", type=int, default=0)
+    add("--device", default="auto", choices=["auto", "cuda", "cpu"])
+    add("--min_free_gpu_mb", type=int, default=4096)
+    add("--skip_gpu_preflight", action="store_true")
+
+    add("--use_first_answer_only", action="store_true")
+    add("--require_answer_in_context", action="store_true")
+    return parser
+
+
+def load_datasets(args):
+    load_kwargs = {
+        "use_all_answers": not args.use_first_answer_only,
+        "task_prefix": args.task_prefix,
+        "require_answer_in_context": args.require_answer_in_context,
+    }
+    train_examples, train_stats = load_squad_qg_examples(args.train_file, **load_kwargs)
+    if not train_examples:
+        raise ValueError("Không có dữ liệu train hợp lệ sau khi tiền xử lý.")
+
+    train_dataset = Dataset.from_list(train_examples)
+    val_dataset = None
+    val_stats = None
+
+    if args.validation_file:
+        val_examples, val_stats = load_squad_qg_examples(args.validation_file, **load_kwargs)
+        if not val_examples:
+            raise ValueError("Không có dữ liệu validation hợp lệ sau khi tiền xử lý.")
+        val_dataset = Dataset.from_list(val_examples)
+    elif args.val_ratio > 0 and len(train_dataset) > 10:
+        split = train_dataset.train_test_split(test_size=args.val_ratio, seed=args.seed)
+        train_dataset, val_dataset = split["train"], split["test"]
+
+    return train_dataset, val_dataset, train_stats, val_stats
+
+
+def tokenize_dataset(dataset, tokenizer, args):
+    return dataset.map(
+        lambda batch: preprocess_function(batch, tokenizer, args.max_source_length, args.max_target_length),
+        batched=True,
+        remove_columns=dataset.column_names,
+    )
+
+
+def build_trainer(model, tokenizer, training_args, train_dataset, eval_dataset, args):
+    kwargs = {
+        "model": model,
+        "args": training_args,
+        "data_collator": DataCollatorForSeq2Seq(tokenizer=tokenizer, model=model),
+        "train_dataset": train_dataset,
+        "eval_dataset": eval_dataset,
+        "callbacks": [EarlyStoppingCallback(early_stopping_patience=args.early_stopping_patience)]
+        if eval_dataset is not None
+        else None,
+        "processing_class": tokenizer,
+    }
+    return Seq2SeqTrainer(
+        **build_supported_kwargs(Seq2SeqTrainer, kwargs, aliases={"processing_class": "tokenizer"})
+    )
+
+
+def main() -> None:
+    args = build_parser().parse_args()
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    set_seed(args.seed)
+    ensure_device_ready(args)
+
+    raw_train_dataset, raw_val_dataset, train_stats, val_stats = load_datasets(args)
+    has_eval = raw_val_dataset is not None
+    validate_args(args, has_eval)
+
+    tokenizer = AutoTokenizer.from_pretrained(args.model_name)
+    model = AutoModelForSeq2SeqLM.from_pretrained(args.model_name)
+
+    if args.gradient_checkpointing:
+        model.gradient_checkpointing_enable()
+        if hasattr(model.config, "use_cache"):
+            model.config.use_cache = False
+
+    tokenized_train = tokenize_dataset(raw_train_dataset, tokenizer, args)
+    tokenized_val = tokenize_dataset(raw_val_dataset, tokenizer, args) if has_eval else None
+    trainer = build_trainer(
+        model,
+        tokenizer,
+        build_training_args(args, has_eval),
+        tokenized_train,
+        tokenized_val,
+        args,
+    )
+
+    resume_checkpoint = resolve_resume_checkpoint(args)
+    try:
+        train_result = trainer.train(resume_from_checkpoint=resume_checkpoint)
+    except torch.OutOfMemoryError:
+        raise_cuda_oom(args)
+    except RuntimeError as exc:
+        if "CUDA out of memory" in str(exc):
+            raise_cuda_oom(args)
+        raise
+
+    trainer.save_state()
+
+    export_dir = output_dir / ("best-model" if has_eval else "final-model")
+    export_dir.mkdir(parents=True, exist_ok=True)
+    for path in (export_dir, output_dir):
+        trainer.save_model(str(path))
+        tokenizer.save_pretrained(str(path))
+
+    train_metrics = train_result.metrics
+    trainer.log_metrics("train", train_metrics)
+    trainer.save_metrics("train", train_metrics)
+
+    eval_metrics = None
+    if has_eval:
+        eval_metrics = trainer.evaluate(
+            max_length=args.max_target_length,
+            num_beams=4,
+            metric_key_prefix="eval",
+        )
+        trainer.log_metrics("eval", eval_metrics)
+        trainer.save_metrics("eval", eval_metrics)
+
+    save_json(
+        {
+            "base_model": args.model_name,
+            "task_prefix": args.task_prefix,
+            "output_dir": str(output_dir),
+            "export_dir": str(export_dir),
+            "train_size": len(raw_train_dataset),
+            "val_size": len(raw_val_dataset) if raw_val_dataset is not None else 0,
+            "train_stats": train_stats,
+            "val_stats": val_stats,
+            "best_model_checkpoint": trainer.state.best_model_checkpoint,
+            "best_metric": trainer.state.best_metric,
+            "resumed_from_checkpoint": resume_checkpoint,
+            "args": vars(args),
+            "train_metrics": train_metrics,
+            "eval_metrics": eval_metrics,
+        },
+        output_dir / "training_summary.json",
+    )
+
+
+if __name__ == "__main__":
+    main()

HVU_QA/generate_question.py

@@ -0,0 +1,383 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+import threading
+from pathlib import Path
+from typing import Any
+
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
+
+
+def raise_missing_dependency_error(exc: ModuleNotFoundError) -> None:
+    root = Path(__file__).resolve().parent
+    requirements = root / "requirements.txt"
+    message = [
+        f"Thiếu thư viện Python: {exc.name}",
+        f"Interpreter hiện tại: {sys.executable}",
+    ]
+    if requirements.exists():
+        message.extend(
+            [
+                "Cài đặt dependencies bằng lệnh:",
+                f"{sys.executable} -m pip install -r {requirements}",
+            ]
+        )
+    raise SystemExit("\n".join(message)) from exc
+
+
+try:
+    import torch
+    from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
+except ModuleNotFoundError as exc:
+    raise_missing_dependency_error(exc)
+
+
+APP_TITLE = "Mô hình sinh câu hỏi thường gặp"
+TASK_PREFIX = "sinh câu hỏi"
+QUESTION_LIMIT = 100
+GENERATION_PASSES = (
+    (0.9, 0.95, None, 1, 4),
+    (1.0, 0.97, 16, 1, 5),
+    (1.08, 0.99, 8, 2, 6),
+)
+
+
+def normalize_text(text: Any) -> str:
+    return " ".join(str(text or "").split())
+
+
+def unique_text(items: list[str]) -> list[str]:
+    seen: set[str] = set()
+    output: list[str] = []
+    for item in items:
+        value = normalize_text(item)
+        key = value.lower()
+        if key and key not in seen:
+            seen.add(key)
+            output.append(value)
+    return output
+
+
+def parse_question_count(value: Any, default: int = 5) -> int:
+    try:
+        parsed = int(value)
+    except (TypeError, ValueError):
+        parsed = default
+    return max(1, min(parsed, QUESTION_LIMIT))
+
+
+def format_questions(items: list[str]) -> str:
+    if not items:
+        return "Không sinh được câu hỏi phù hợp."
+    return "\n".join(f"{index}. {item}" for index, item in enumerate(items, 1))
+
+
+def resolve_model_dir(model_dir: str | Path, prefer_nested_model: bool = True) -> Path:
+    model_root = Path(model_dir).expanduser().resolve()
+    nested_candidates = [model_root / "best-model", model_root / "final-model"]
+    candidates = [*nested_candidates, model_root] if prefer_nested_model else [model_root, *nested_candidates]
+    for candidate in candidates:
+        if candidate.is_dir() and (candidate / "config.json").exists():
+            return candidate
+    raise FileNotFoundError(f"Không tìm thấy thư mục mô hình hợp lệ: {model_root}")
+
+
+def parse_dtype(value: str) -> torch.dtype:
+    normalized = value.strip().lower()
+    mapping = {
+        "float16": torch.float16,
+        "fp16": torch.float16,
+        "float32": torch.float32,
+        "fp32": torch.float32,
+        "bfloat16": torch.bfloat16,
+        "bf16": torch.bfloat16,
+    }
+    if normalized not in mapping:
+        raise ValueError(f"Không hỗ trợ gpu_dtype={value}")
+    return mapping[normalized]
+
+
+class QuestionGenerator:
+    def __init__(
+        self,
+        model_dir: str | Path = "t5-viet-qg-finetuned",
+        task_prefix: str = TASK_PREFIX,
+        max_source_length: int = 512,
+        max_new_tokens: int = 64,
+        device: str = "auto",
+        cpu_threads: int | None = None,
+        gpu_dtype: str = "auto",
+        prefer_nested_model: bool = True,
+    ) -> None:
+        self.model_root = Path(model_dir).expanduser().resolve()
+        self.model_dir = resolve_model_dir(model_dir, prefer_nested_model=prefer_nested_model)
+        self.task_prefix = task_prefix
+        self.max_source_length = max_source_length
+        self.max_new_tokens = max_new_tokens
+        self.requested_device = device
+        self.cpu_threads = cpu_threads
+        self.gpu_dtype = gpu_dtype
+        self.prefer_nested_model = prefer_nested_model
+        self.device: torch.device | None = None
+        self.dtype: torch.dtype | None = None
+        self.tokenizer = None
+        self.model = None
+        self._load_lock = threading.Lock()
+
+    def _resolve_device(self) -> torch.device:
+        requested = self.requested_device.lower()
+        if requested == "cpu":
+            return torch.device("cpu")
+        if requested == "cuda":
+            if not torch.cuda.is_available():
+                raise RuntimeError("Bạn đã chọn device=cuda nhưng máy hiện tại không có CUDA.")
+            return torch.device("cuda")
+        return torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    def _resolve_dtype(self) -> torch.dtype:
+        if self.device is None or self.device.type != "cuda":
+            return torch.float32
+        if self.gpu_dtype == "auto":
+            if hasattr(torch.cuda, "is_bf16_supported") and torch.cuda.is_bf16_supported():
+                return torch.bfloat16
+            return torch.float16
+        return parse_dtype(self.gpu_dtype)
+
+    def _configure_runtime(self) -> None:
+        if self.device is None:
+            return
+        if self.device.type == "cpu":
+            if self.cpu_threads:
+                torch.set_num_threads(max(1, int(self.cpu_threads)))
+                if hasattr(torch, "set_num_interop_threads"):
+                    torch.set_num_interop_threads(max(1, min(int(self.cpu_threads), 4)))
+            return
+
+        if hasattr(torch.backends, "cuda") and hasattr(torch.backends.cuda, "matmul"):
+            torch.backends.cuda.matmul.allow_tf32 = True
+        if hasattr(torch.backends, "cudnn"):
+            torch.backends.cudnn.allow_tf32 = True
+            torch.backends.cudnn.benchmark = True
+
+    def load(self) -> None:
+        if self.model is not None and self.tokenizer is not None:
+            return
+
+        with self._load_lock:
+            if self.model is not None and self.tokenizer is not None:
+                return
+
+            self.device = self._resolve_device()
+            self.dtype = self._resolve_dtype()
+            self._configure_runtime()
+
+            model_kwargs: dict[str, Any] = {}
+            if self.device.type == "cuda":
+                model_kwargs["torch_dtype"] = self.dtype
+                model_kwargs["low_cpu_mem_usage"] = True
+
+            self.tokenizer = AutoTokenizer.from_pretrained(str(self.model_dir), use_fast=True)
+            self.model = AutoModelForSeq2SeqLM.from_pretrained(str(self.model_dir), **model_kwargs)
+            self.model.to(self.device)
+            self.model.eval()
+
+    def metadata(self) -> dict[str, Any]:
+        active_device = self.device.type if self.device is not None else None
+        predicted_device = "cuda" if torch.cuda.is_available() and self.requested_device != "cpu" else "cpu"
+        return {
+            "title": APP_TITLE,
+            "model_root": str(self.model_root),
+            "model_dir": str(self.model_dir),
+            "requested_device": self.requested_device,
+            "active_device": active_device,
+            "predicted_device": predicted_device,
+            "loaded": self.model is not None,
+            "gpu_available": torch.cuda.is_available(),
+            "gpu_dtype": None if self.dtype is None else str(self.dtype).replace("torch.", ""),
+            "cpu_threads": torch.get_num_threads(),
+        }
+
+    def _candidate_answers(self, text: str, limit: int) -> list[str]:
+        text = normalize_text(text)
+        if not text:
+            return []
+
+        candidates: list[str] = []
+        split_pattern = r"(?<=[.!?])\s+|\n+"
+        for sentence in [normalize_text(part) for part in re.split(split_pattern, text) if normalize_text(part)]:
+            if 3 <= len(sentence.split()) <= 30:
+                candidates.append(sentence)
+            for clause in (normalize_text(part) for part in re.split(r"\s*[,;:]\s*", sentence)):
+                if 3 <= len(clause.split()) <= 20:
+                    candidates.append(clause)
+
+        if not candidates:
+            words = text.split()
+            candidates = [" ".join(words[: min(12, len(words))])] if words else [text]
+
+        ranked = sorted(unique_text(candidates), key=lambda item: (abs(len(item.split()) - 10), len(item)))
+        return ranked[:limit]
+
+    def _build_prompt(self, context: str, answer: str) -> str:
+        return f"{self.task_prefix}:\nngữ cảnh: {context}\nđáp án: {answer}"
+
+    @torch.inference_mode()
+    def _sample(self, context: str, answer: str, count: int, temperature: float, top_p: float) -> list[str]:
+        if self.tokenizer is None or self.model is None or self.device is None:
+            raise RuntimeError("Model chưa được load.")
+
+        inputs = self.tokenizer(
+            self._build_prompt(context, answer),
+            return_tensors="pt",
+            truncation=True,
+            max_length=self.max_source_length,
+        ).to(self.device)
+        outputs = self.model.generate(
+            **inputs,
+            max_new_tokens=self.max_new_tokens,
+            do_sample=True,
+            temperature=temperature,
+            top_p=top_p,
+            num_return_sequences=count,
+            no_repeat_ngram_size=3,
+            repetition_penalty=1.1,
+        )
+        questions: list[str] = []
+        for token_ids in outputs:
+            question = normalize_text(self.tokenizer.decode(token_ids, skip_special_tokens=True))
+            if question:
+                questions.append(question if question.endswith("?") else f"{question}?")
+        return [question for question in unique_text(questions) if len(question.split()) >= 3]
+
+    @torch.inference_mode()
+    def _beam_search(self, context: str, answer: str, count: int) -> list[str]:
+        if self.tokenizer is None or self.model is None or self.device is None:
+            raise RuntimeError("Model chưa được load.")
+
+        inputs = self.tokenizer(
+            self._build_prompt(context, answer),
+            return_tensors="pt",
+            truncation=True,
+            max_length=self.max_source_length,
+        ).to(self.device)
+        outputs = self.model.generate(
+            **inputs,
+            max_new_tokens=self.max_new_tokens,
+            num_beams=max(4, count),
+            num_return_sequences=min(count, 4),
+            early_stopping=True,
+            no_repeat_ngram_size=3,
+            repetition_penalty=1.1,
+        )
+        questions: list[str] = []
+        for token_ids in outputs:
+            question = normalize_text(self.tokenizer.decode(token_ids, skip_special_tokens=True))
+            if question:
+                questions.append(question if question.endswith("?") else f"{question}?")
+        return [question for question in unique_text(questions) if len(question.split()) >= 3]
+
+    def generate(self, text: str, count: int = 5) -> list[str]:
+        self.load()
+        context = normalize_text(text)
+        if not context:
+            raise ValueError("Vui lòng nhập đoạn văn.")
+
+        count = parse_question_count(count)
+        pool = unique_text(
+            self._candidate_answers(context, max(32, count * 5)) + [context[:180], context[:280], context]
+        )
+        output: list[str] = []
+        seen: set[str] = set()
+
+        for temperature, top_p, limit, rounds, floor in GENERATION_PASSES:
+            answers = pool[:limit] if limit else pool
+            for _ in range(rounds):
+                for answer in answers:
+                    remaining = count - len(output)
+                    if remaining <= 0:
+                        return output[:count]
+                    sample_count = min(8, max(floor, remaining * 2))
+                    for question in self._sample(context, answer, sample_count, temperature, top_p):
+                        key = question.lower()
+                        if key not in seen:
+                            seen.add(key)
+                            output.append(question)
+                            if len(output) >= count:
+                                return output[:count]
+
+        for answer in pool[: min(8, len(pool))]:
+            remaining = count - len(output)
+            if remaining <= 0:
+                break
+            for question in self._beam_search(context, answer, remaining):
+                key = question.lower()
+                if key not in seen:
+                    seen.add(key)
+                    output.append(question)
+                    if len(output) >= count:
+                        break
+
+        return output[:count]
+
+
+def read_input_text(args: argparse.Namespace) -> str:
+    if args.text:
+        return args.text
+    if args.input_file:
+        return Path(args.input_file).read_text(encoding="utf-8")
+    if sys.stdin.isatty():
+        return input("Nhập đoạn văn cần sinh câu hỏi:\n").strip()
+    return sys.stdin.read().strip()
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Sinh câu hỏi từ đoạn văn bằng model T5 fine-tuned.")
+    parser.add_argument("--model_dir", default="t5-viet-qg-finetuned")
+    parser.add_argument("--task_prefix", default=TASK_PREFIX)
+    parser.add_argument("--max_source_length", type=int, default=512)
+    parser.add_argument("--max_new_tokens", type=int, default=64)
+    parser.add_argument("--num_questions", type=int, default=100)
+    parser.add_argument("--device", choices=["auto", "cpu", "cuda"], default="auto")
+    parser.add_argument("--cpu_threads", type=int, default=None)
+    parser.add_argument("--gpu_dtype", default="auto")
+    parser.add_argument("--text", default=None)
+    parser.add_argument("--input_file", default=None)
+    parser.add_argument("--output_format", choices=["text", "json"], default="text")
+    return parser
+
+
+def main() -> None:
+    args = build_parser().parse_args()
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8")
+    generator = QuestionGenerator(
+        model_dir=args.model_dir,
+        task_prefix=args.task_prefix,
+        max_source_length=args.max_source_length,
+        max_new_tokens=args.max_new_tokens,
+        device=args.device,
+        cpu_threads=args.cpu_threads,
+        gpu_dtype=args.gpu_dtype,
+        prefer_nested_model=True,
+    )
+    text = read_input_text(args)
+    questions = generator.generate(text, parse_question_count(args.num_questions))
+    payload = {
+        "text": normalize_text(text),
+        "questions": questions,
+        "formatted": format_questions(questions),
+        "meta": generator.metadata(),
+    }
+    if args.output_format == "json":
+        print(json.dumps(payload, ensure_ascii=False, indent=2))
+        return
+    print(payload["formatted"])
+
+
+if __name__ == "__main__":
+    main()

HVU_QA/main.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import os
+import threading
+import webbrowser
+
+from backend import create_app
+
+app = create_app()
+
+
+def _as_bool(value: str | None, default: bool) -> bool:
+    if value is None:
+        return default
+    return value.strip().lower() not in {"0", "false", "no", "off"}
+
+
+def _open_browser_later(host: str, port: int) -> None:
+    if not _as_bool(os.getenv("HVU_OPEN_BROWSER"), True):
+        return
+    target_host = "127.0.0.1" if host in {"0.0.0.0", "::"} else host
+    url = f"http://{target_host}:{port}"
+    threading.Timer(1.2, lambda: webbrowser.open(url)).start()
+
+
+if __name__ == "__main__":
+    host = os.getenv("HVU_HOST", "127.0.0.1")
+    port = int(os.getenv("HVU_PORT", "5000"))
+    debug = _as_bool(os.getenv("HVU_DEBUG"), False)
+    _open_browser_later(host, port)
+    app.run(host=host, port=port, debug=debug, use_reloader=False)