from __future__ import annotations import argparse import json import random import re from collections import Counter from pathlib import Path from typing import Any import numpy as np import torch import yaml from sklearn.utils.class_weight import compute_class_weight from torch.utils.data import Dataset, WeightedRandomSampler from transformers import EarlyStoppingCallback, Trainer, TrainingArguments, set_seed from src.data.io_utils import read_csv_dicts, read_jsonl, write_csv, write_json, write_jsonl from src.eval.calibration import expected_calibration_error from src.eval.confusion_matrix import confusion_matrix_rows from src.models.encoder_verifier import load_sequence_classifier, load_tokenizer, sanitize_model_name from src.utils.metrics import classification_metrics, softmax class VerifierDataset(Dataset): def __init__(self, rows: list[dict[str, Any]], tokenizer: Any, label2id: dict[str, int], max_length: int): self.rows = rows self.encodings = tokenizer( [row["input_text"] for row in rows], padding=True, truncation=True, max_length=max_length, ) self.labels = [label2id[row["label"]] for row in rows] def __len__(self) -> int: return len(self.rows) def __getitem__(self, idx: int) -> dict[str, torch.Tensor]: item = {key: torch.tensor(value[idx]) for key, value in self.encodings.items()} item["labels"] = torch.tensor(self.labels[idx], dtype=torch.long) return item class WeightedTrainer(Trainer): def __init__( self, class_weights: torch.Tensor | None = None, train_sampler: WeightedRandomSampler | None = None, loss_type: str = "cross_entropy", focal_gamma: float = 2.0, **kwargs: Any, ): super().__init__(**kwargs) self.class_weights = class_weights self.train_sampler = train_sampler self.loss_type = loss_type self.focal_gamma = focal_gamma def _get_train_sampler(self, train_dataset: Dataset | None = None) -> torch.utils.data.Sampler | None: if self.train_sampler is not None: return self.train_sampler return super()._get_train_sampler(train_dataset) def compute_loss( self, model: torch.nn.Module, inputs: dict[str, torch.Tensor | Any], return_outputs: bool = False, num_items_in_batch: torch.Tensor | int | None = None, ) -> torch.Tensor | tuple[torch.Tensor, Any]: labels = inputs.pop("labels") outputs = model(**inputs) logits = outputs.logits weights = self.class_weights.to(logits.device) if self.class_weights is not None else None logits = logits.view(-1, logits.shape[-1]) labels = labels.view(-1) if self.loss_type == "focal_loss": log_probs = torch.nn.functional.log_softmax(logits, dim=-1) log_pt = log_probs.gather(1, labels.unsqueeze(1)).squeeze(1) pt = log_pt.exp() ce_loss = torch.nn.functional.nll_loss(log_probs, labels, weight=weights, reduction="none") loss = ((1 - pt) ** self.focal_gamma * ce_loss).mean() else: loss = torch.nn.functional.cross_entropy(logits, labels, weight=weights) return (loss, outputs) if return_outputs else loss def effective_max_length(tokenizer: Any, requested: int) -> int: tokenizer_max = getattr(tokenizer, "model_max_length", None) if isinstance(tokenizer_max, int) and 0 < tokenizer_max < 100_000: return min(requested, tokenizer_max) return requested def token_length_stats(rows: list[dict[str, Any]], tokenizer: Any, max_length: int) -> dict[str, Any]: lengths: list[int] = [] for row in rows: ids = tokenizer(row["input_text"], truncation=False, add_special_tokens=True)["input_ids"] lengths.append(len(ids)) if not lengths: return {"avg_tokens": 0.0, "max_tokens": 0, "pct_over_max_length": 0.0} over = sum(1 for length in lengths if length > max_length) return { "avg_tokens": round(float(np.mean(lengths)), 4), "max_tokens": int(max(lengths)), "pct_over_max_length": round(over / len(lengths), 6), } def normalized_class_weights(counts: list[int], mode: str) -> np.ndarray: total = sum(counts) safe_counts = np.array([max(1, count) for count in counts], dtype=np.float64) if mode == "inverse_frequency": weights = total / safe_counts elif mode == "inverse_sqrt_frequency": weights = np.sqrt(total / safe_counts) else: raise ValueError(f"Unsupported class weight mode: {mode}") return weights / weights.mean() def class_weights_for(rows: list[dict[str, Any]], label_set: list[str], label2id: dict[str, int], mode: str | None) -> torch.Tensor | None: if mode in (None, "", "none", "None"): return None mode = str(mode) labels = np.array([label2id[row["label"]] for row in rows]) classes = np.arange(len(label_set)) if mode == "balanced": weights = compute_class_weight(class_weight="balanced", classes=classes, y=labels) elif mode in {"inverse_frequency", "inverse_sqrt_frequency"}: counts_by_id = Counter(int(label_id) for label_id in labels) counts = [counts_by_id.get(class_id, 0) for class_id in classes] weights = normalized_class_weights(counts, mode) else: raise ValueError(f"Unsupported class weight mode: {mode}") return torch.tensor(weights, dtype=torch.float) def sampler_for(rows: list[dict[str, Any]], label2id: dict[str, int], cfg: dict[str, Any] | None) -> WeightedRandomSampler | None: if not cfg or cfg.get("type") != "weighted_random_sampler": return None mode = str(cfg.get("weight_mode", "inverse_frequency")) cap = float(cfg.get("minority_sampling_cap", cfg.get("cap", 3.0))) labels = [label2id[row["label"]] for row in rows] counts_by_id = Counter(labels) counts = [counts_by_id.get(class_id, 0) for class_id in range(len(label2id))] class_weights = normalized_class_weights(counts, mode) if cap > 0: min_weight = float(class_weights.min()) class_weights = np.minimum(class_weights, min_weight * cap) sample_weights = torch.tensor([float(class_weights[label_id]) for label_id in labels], dtype=torch.double) return WeightedRandomSampler(sample_weights, num_samples=len(sample_weights), replacement=True) def write_predictions( path: Path, rows: list[dict[str, Any]], probs: np.ndarray, pred_ids: np.ndarray, id2label: dict[int, str], model_name: str, seed: int, ) -> None: out_rows: list[dict[str, Any]] = [] for row, prob, pred_id in zip(rows, probs, pred_ids, strict=False): evidence = row.get("evidence", []) out_rows.append( { "id": row.get("id"), "dataset": row.get("dataset"), "split": row.get("split"), "gold": row.get("label"), "prediction": id2label[int(pred_id)], "confidence": round(float(prob.max()), 6), "probabilities": {id2label[idx]: round(float(value), 6) for idx, value in enumerate(prob)}, "model_name": model_name, "seed": seed, "claim": row.get("claim"), "evidence_ids": [item.get("candidate_id") for item in evidence], } ) write_jsonl(path, out_rows) def evaluate_split( trainer: Trainer, rows: list[dict[str, Any]], dataset: VerifierDataset, split_key: str, output_dir: Path, label_set: list[str], id2label: dict[int, str], model_name: str, seed: int, ) -> dict[str, Any]: pred = trainer.predict(dataset) logits = np.asarray(pred.predictions) probs = softmax(logits) pred_ids = probs.argmax(axis=1) true_ids = np.asarray([label_set.index(row["label"]) for row in rows]) y_true = [row["label"] for row in rows] y_pred = [id2label[int(idx)] for idx in pred_ids] metrics = classification_metrics(label_set, y_true, y_pred) metrics["ece"] = expected_calibration_error(probs, true_ids) metrics["split"] = split_key metrics["eval_size"] = len(rows) write_predictions(output_dir / f"predictions_{split_key}.jsonl", rows, probs, pred_ids, id2label, model_name, seed) write_csv(output_dir / f"confusion_matrix_{split_key}.csv", confusion_matrix_rows(label_set, y_true, y_pred)) return metrics def update_csv_by_key(path: Path, new_rows: list[dict[str, Any]], key_fields: list[str]) -> None: existing = read_csv_dicts(path) if path.exists() else [] new_keys = {tuple(str(row.get(field, "")) for field in key_fields) for row in new_rows} kept = [row for row in existing if tuple(str(row.get(field, "")) for field in key_fields) not in new_keys] write_csv(path, kept + new_rows) def aggregate_seed_metrics(seed_metrics: list[dict[str, Any]], key: str) -> tuple[float, float]: values = [float(row[key]) for row in seed_metrics] return round(float(np.mean(values)), 6), round(float(np.std(values, ddof=0)), 6) def load_available_seed_results(base_dir: Path, in_memory_results: list[dict[str, Any]]) -> list[dict[str, Any]]: results_by_seed = {int(row["seed"]): row for row in in_memory_results} for metrics_path in base_dir.glob("seed_*/metrics.json"): try: metrics = json.loads(metrics_path.read_text(encoding="utf-8")) except (OSError, json.JSONDecodeError): continue if "seed" in metrics and "test" in metrics: results_by_seed[int(metrics["seed"])] = metrics return [results_by_seed[seed] for seed in sorted(results_by_seed)] def loss_name(cfg: dict[str, Any]) -> str: loss_cfg = cfg.get("loss") or {} loss_type = str(loss_cfg.get("type", "cross_entropy")) class_weight_mode = loss_cfg.get("class_weight_mode") if class_weight_mode is None: class_weight_mode = (cfg.get("training") or {}).get("class_weight") if loss_type == "focal_loss": gamma = float(loss_cfg.get("gamma", 2.0)) suffix = f":{class_weight_mode}" if class_weight_mode else "" return f"focal_loss:gamma={gamma:g}{suffix}" if class_weight_mode: return f"weighted_cross_entropy:{class_weight_mode}" return loss_type def input_metadata(cfg: dict[str, Any]) -> dict[str, str]: train_path = Path(cfg["input"]["train"]) top_match = re.search(r"_top(\d+)", train_path.stem) top_k = top_match.group(1) if top_match else "" input_format = str((cfg.get("input") or {}).get("format") or cfg.get("input_format") or "flat") if train_path.stem.endswith("_qa"): input_format = "qa" return {"top_k": top_k, "input_format": input_format} def method_metadata( dataset: str, model_name: str, top_k: str, loss: str, sampler: dict[str, Any] | None, input_format: str, ) -> dict[str, str]: if dataset == "healthver": return { "Protocol": "P6", "Method": "PubMedBERT baseline", "Evidence source": "paired evidence + augmentation", "Notes": "pair-level anchored protocol", } if dataset == "vifactcheck": return { "Protocol": "P1", "Method": "XLM-R baseline", "Evidence source": "context chunks", "Notes": "gold Evidence excluded from main input", } model_family = "DeBERTa-v3-large" if "deberta" in model_name.lower() else "ModernBERT" sampler_suffix = " sampler" if sampler and sampler.get("type") == "weighted_random_sampler" else "" qa_suffix = " QA" if input_format == "qa" else "" if "deberta" in model_name.lower(): loss_suffix = " focal" if loss.startswith("focal_loss") else "" return { "Protocol": "P4", "Method": f"{model_family} top{top_k}{qa_suffix}{loss_suffix} weighted{sampler_suffix} rescue", "Evidence source": "retrieved evidence", "Notes": "AVeriTeC rescue candidate; official dev used as local_test; hidden test excluded", } if sampler and sampler.get("type") == "weighted_random_sampler": loss_suffix = " focal" if loss.startswith("focal_loss") else "" return { "Protocol": "P4", "Method": f"{model_family} top{top_k}{qa_suffix}{loss_suffix} weighted sampler rescue", "Evidence source": "retrieved evidence", "Notes": "AVeriTeC rescue candidate with weighted sampler; official dev used as local_test; hidden test excluded", } if top_k == "10": loss_suffix = " focal" if loss.startswith("focal_loss") else "" return { "Protocol": "P4", "Method": f"{model_family} top{top_k}{qa_suffix}{loss_suffix} weighted rescue", "Evidence source": "retrieved evidence", "Notes": "AVeriTeC rescue candidate; official dev used as local_test; hidden test excluded", } return { "Protocol": "P4", "Method": "ModernBERT baseline", "Evidence source": "retrieved evidence", "Notes": "official dev used as local_test; hidden test excluded", } def run_seed(cfg: dict[str, Any], seed: int, output_dir: Path) -> dict[str, Any]: random.seed(seed) np.random.seed(seed) torch.manual_seed(seed) set_seed(seed) dataset_name = cfg["dataset"] model_name = cfg["model_name"] label_set = list(cfg["label_set"]) label2id = {label: idx for idx, label in enumerate(label_set)} id2label = {idx: label for label, idx in label2id.items()} training_cfg = cfg["training"] train_rows = [row for row in read_jsonl(Path(cfg["input"]["train"])) if row.get("label") in label2id] dev_rows = [row for row in read_jsonl(Path(cfg["input"]["dev"])) if row.get("label") in label2id] test_rows = [row for row in read_jsonl(Path(cfg["input"]["test"])) if row.get("label") in label2id] tokenizer = load_tokenizer(model_name) requested_max_length = int(training_cfg.get("max_length", 512)) max_length = effective_max_length(tokenizer, requested_max_length) model = load_sequence_classifier(model_name, len(label_set), label_set) train_dataset = VerifierDataset(train_rows, tokenizer, label2id, max_length=max_length) dev_dataset = VerifierDataset(dev_rows, tokenizer, label2id, max_length=max_length) test_dataset = VerifierDataset(test_rows, tokenizer, label2id, max_length=max_length) loss_cfg = cfg.get("loss") or {} loss_type = loss_cfg.get("type", "cross_entropy") focal_gamma = float(loss_cfg.get("gamma", 2.0)) class_weight_mode = loss_cfg.get("class_weight_mode") if class_weight_mode is None: class_weight_mode = training_cfg.get("class_weight") if loss_type not in {"cross_entropy", "weighted_cross_entropy", "focal_loss"}: raise ValueError(f"Unsupported loss type: {loss_type}") if loss_type == "weighted_cross_entropy" and not class_weight_mode: raise ValueError("loss.type=weighted_cross_entropy requires loss.class_weight_mode") weights = class_weights_for(train_rows, label_set, label2id, class_weight_mode) train_sampler = sampler_for(train_rows, label2id, cfg.get("sampler")) args = TrainingArguments( output_dir=str(output_dir / "trainer"), num_train_epochs=float(training_cfg.get("epochs", 3)), per_device_train_batch_size=int(training_cfg.get("batch_size", 8)), per_device_eval_batch_size=int(training_cfg.get("eval_batch_size", training_cfg.get("batch_size", 8))), gradient_accumulation_steps=int(training_cfg.get("gradient_accumulation_steps", 1)), learning_rate=float(training_cfg.get("learning_rate", 2e-5)), weight_decay=float(training_cfg.get("weight_decay", 0.01)), warmup_ratio=float(training_cfg.get("warmup_ratio", 0.06)), eval_strategy="epoch", save_strategy="epoch", logging_strategy="steps", logging_steps=int(training_cfg.get("logging_steps", 25)), load_best_model_at_end=True, metric_for_best_model=str(training_cfg.get("metric_for_best_model", "macro_f1")), greater_is_better=True, save_total_limit=1, bf16=bool(training_cfg.get("precision") == "bf16" and torch.cuda.is_available()), fp16=bool(training_cfg.get("precision") == "fp16" and torch.cuda.is_available()), report_to=[], seed=seed, dataloader_num_workers=int(training_cfg.get("dataloader_num_workers", 0)), ) def compute_metrics(eval_pred: Any) -> dict[str, float]: logits, labels = eval_pred pred_ids = np.asarray(logits).argmax(axis=1) y_true = [id2label[int(idx)] for idx in labels] y_pred = [id2label[int(idx)] for idx in pred_ids] metrics = classification_metrics(label_set, y_true, y_pred) return { "accuracy": metrics["accuracy"], "macro_f1": metrics["macro_f1"], "weighted_f1": metrics["weighted_f1"], } trainer = WeightedTrainer( model=model, args=args, train_dataset=train_dataset, eval_dataset=dev_dataset, processing_class=tokenizer, compute_metrics=compute_metrics, callbacks=[EarlyStoppingCallback(early_stopping_patience=int(training_cfg.get("early_stopping_patience", 2)))], class_weights=weights, train_sampler=train_sampler, loss_type=loss_type, focal_gamma=focal_gamma, ) trainer.train() dev_metrics = evaluate_split(trainer, dev_rows, dev_dataset, "dev", output_dir, label_set, id2label, model_name, seed) test_metrics = evaluate_split(trainer, test_rows, test_dataset, "test", output_dir, label_set, id2label, model_name, seed) train_token_stats = token_length_stats(train_rows, tokenizer, max_length) dev_token_stats = token_length_stats(dev_rows, tokenizer, max_length) test_token_stats = token_length_stats(test_rows, tokenizer, max_length) training_log = trainer.state.log_history write_jsonl(output_dir / "training_log.jsonl", training_log) metrics = { "dataset": dataset_name, "model_name": model_name, "seed": seed, "label_set": label_set, "requested_max_length": requested_max_length, "effective_max_length": max_length, "train_size": len(train_rows), "loss": { "type": loss_type, "gamma": focal_gamma if loss_type == "focal_loss" else None, "class_weight_mode": class_weight_mode, "class_weights": [round(float(value), 6) for value in weights.tolist()] if weights is not None else None, }, "sampler": cfg.get("sampler"), "dev": dev_metrics, "test": test_metrics, "token_stats": { "train": train_token_stats, "dev": dev_token_stats, "test": test_token_stats, }, } write_json(output_dir / "metrics.json", metrics) return metrics def update_summary_tables(cfg: dict[str, Any], model_dir_name: str, seed_results: list[dict[str, Any]], output_root: Path) -> None: dataset = cfg["dataset"] model_name = cfg["model_name"] test_seed_metrics = [row["test"] for row in seed_results] acc_mean, acc_std = aggregate_seed_metrics(test_seed_metrics, "accuracy") f1_mean, f1_std = aggregate_seed_metrics(test_seed_metrics, "macro_f1") per_class = test_seed_metrics[-1].get("per_class_f1", "{}") input_meta = input_metadata(cfg) top_k = input_meta["top_k"] input_format = input_meta["input_format"] loss = loss_name(cfg) meta = method_metadata(dataset, model_name, top_k, loss, cfg.get("sampler"), input_format) seed_count = len(seed_results) last_per_class = test_seed_metrics[-1].get("per_class", {}) collapse_labels = [ label for label, values in last_per_class.items() if float(values.get("f1", 0.0)) < 0.1 and (dataset == "averitec" or float(values.get("support", 0)) > 0) ] collapse_warning = "No" if not collapse_labels else f"YES: {'/'.join(collapse_labels)} collapse" averitec_rescue_minimum_pass = True if dataset == "averitec": nei_f1 = float(last_per_class.get("NEI", {}).get("f1", 0.0)) conflicting_f1 = float(last_per_class.get("CONFLICTING", {}).get("f1", 0.0)) averitec_rescue_minimum_pass = f1_mean >= 0.4 and nei_f1 > 0.1 and conflicting_f1 > 0.1 if dataset == "averitec" and (collapse_labels or not averitec_rescue_minimum_pass): gate = "NEEDS_RESCUE" strong_gate_status = "PENDING_AVERITEC_RESCUE" elif dataset == "averitec" and seed_count < 3: gate = "RESCUE_MINIMUM_PASS" strong_gate_status = "PENDING_3_SEEDS" elif seed_count >= 3: gate = "STRONG_PASS_CANDIDATE" strong_gate_status = "READY_FOR_STRONG_GATE_REVIEW" else: gate = "MINIMUM_PASS" strong_gate_status = "PENDING_3_SEEDS" t11_row = { "Dataset": dataset, "Protocol": meta["Protocol"], "Method": meta["Method"], "Evidence source": meta["Evidence source"], "Verifier": model_name, "KG/path": "No", "Top-k": top_k, "input_top_k": top_k, "input_format": input_format, "loss_type": loss, "Acc": acc_mean, "Acc std": acc_std, "Macro-F1": f1_mean, "Macro-F1 std": f1_std, "Per-class F1": per_class, "Seeds": ",".join(str(row["seed"]) for row in seed_results), "seed_count": seed_count, "collapse_warning": collapse_warning, "strong_gate_status": strong_gate_status, "Gate": gate, "Notes": meta["Notes"], } update_csv_by_key( output_root / "tables" / "T11_main_verification.csv", [t11_row], key_fields=["Dataset", "Method", "Verifier", "Top-k", "loss_type", "input_format"], ) training = cfg["training"] t5_row = { "Dataset": dataset, "Verifier": model_name, "Model dir": model_dir_name, "Top-k": top_k, "input_format": input_format, "max_length": training.get("max_length"), "batch_size": training.get("batch_size"), "gradient_accumulation_steps": training.get("gradient_accumulation_steps"), "learning_rate": training.get("learning_rate"), "epochs": training.get("epochs"), "precision": training.get("precision"), "loss_type": loss, "sampler": json.dumps(cfg.get("sampler"), sort_keys=True) if cfg.get("sampler") else "", "seeds": ",".join(str(seed) for seed in cfg["training"].get("seeds", [])), } update_csv_by_key( output_root / "tables" / "T5_training_config.csv", [t5_row], key_fields=["Dataset", "Verifier", "Model dir", "Top-k"], ) def main() -> None: parser = argparse.ArgumentParser() parser.add_argument("--config", type=Path, required=True) parser.add_argument("--output-root", type=Path, default=Path("outputs")) parser.add_argument("--seeds", type=int, nargs="*", default=None) parser.add_argument("--refresh-summary-only", action="store_true") args = parser.parse_args() cfg = yaml.safe_load(args.config.read_text(encoding="utf-8")) seeds = args.seeds if args.seeds else list(cfg["training"].get("seeds", [13])) cfg["training"]["seeds"] = seeds model_dir_name = str(cfg.get("output_name") or sanitize_model_name(cfg["model_name"])).replace("/", "__") base_dir = args.output_root / "baselines" / cfg["dataset"] / "encoder_verifier" / model_dir_name base_dir.mkdir(parents=True, exist_ok=True) seed_results: list[dict[str, Any]] = [] if not args.refresh_summary_only: for seed in seeds: seed_dir = base_dir / f"seed_{seed}" seed_dir.mkdir(parents=True, exist_ok=True) seed_results.append(run_seed(cfg, seed, seed_dir)) all_seed_results = load_available_seed_results(base_dir, seed_results) if not all_seed_results: raise FileNotFoundError(f"No seed metrics found under {base_dir}") cfg["training"]["seeds"] = [int(row["seed"]) for row in all_seed_results] write_json(base_dir / "summary.json", {"config": cfg, "seeds": cfg["training"]["seeds"], "results": all_seed_results}) update_summary_tables(cfg, model_dir_name, all_seed_results, args.output_root) print(f"Wrote encoder verifier outputs to {base_dir}") if __name__ == "__main__": main()