Update

HVU_QA/fine_tune_qg.py

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