Upload folder using huggingface_hub

README.md

@@ -17,5 +17,20 @@ research highlights from scientific paper abstracts (MixSub corpus).
 - Training: one epoch on 15,960 pairs, Kaggle dual T4
 - Validation ROUGE-L F1 (plain LCS, no stemming): **26.37**
 
-Pipeline and evaluation protocol: see the `final/` directory of the
-project repository. Trained 2026-08-08.
+## Repository contents
+
+| file | purpose |
+| --- | --- |
+| `train_final.py` | standalone training recipe that produced this model |
+| `train_final.ipynb` | notebook version of the same recipe |
+| `final/` | full data pipeline: abstract recovery, title fetch, dataset build, submission validation |
+
+## Data pipeline summary
+
+~40% of corpus abstracts are truncated mid-sentence. Each row was matched to
+its ScienceDirect PII (100% verified join), resolved to a DOI via Elsevier's
+keyless API, and its complete abstract recovered from Semantic Scholar under
+a label-free >=90%-token-overlap acceptance filter (~95% of truncated rows
+repaired). Paper titles were fetched for 100% of rows and prepended to
+inputs. See `final/README.md` for the full pipeline and negative-results
+summary. Trained 2026-08-08.

final/README.md

@@ -0,0 +1,61 @@
+# SciHigh 2026 Subtask 1 — Final Pipeline
+
+Team Yushkk99. Task: generate research highlights from paper abstracts
+(MixSub corpus, 19,785 ScienceDirect papers). Official metric: ROUGE-L F1.
+
+## Results (validation, 1,985 rows, plain rougeL / no stemming)
+
+| system | val ROUGE-L |
+| --- | --- |
+| FIRE-2025 winning system (reference) | 23.45 |
+| bart-large-cnn, original data | 24.37 |
+| bart-large-cnn, repaired data + titles (run 1) | 26.37 |
+| **Qwen2.5-72B QLoRA, repaired data + titles (run 2)** | **28.33** |
+
+## Pipeline
+
+Data enrichment (all sources free and sanctioned; test rows touched only
+via abstract/title metadata — never highlight fields):
+
+1. `recover_abstracts.py` — ~40% of corpus abstracts are truncated
+   mid-sentence. Each row is matched to its ScienceDirect PII (verified
+   100% by abstract-text join against the dataset's source repository),
+   resolved to a DOI via Elsevier's keyless Article API, and its complete
+   abstract fetched from Semantic Scholar. A label-free acceptance filter
+   (recovered text must contain >=90% of the truncated text's tokens)
+   guarantees same-paper extensions and structurally excludes records
+   containing highlight fields. Acceptance: ~95% of truncated rows.
+2. `fetch_titles.py` — paper titles for 100% of rows via the same keyless
+   PII lookup.
+3. `build_datasets.py` — rebuilds all splits with recovered abstracts
+   normalized to the corpus's punctuation-stripped format (transform
+   validated token-for-token against 5,481 known prefixes, mean agreement
+   0.987), then prepends titles: `<title> | <abstract>`.
+
+Modeling:
+
+4. `train_qwen_qlora.py` — one-epoch QLoRA SFT (4-bit NF4, LoRA r=16 on
+   attention+MLP) of a Qwen2.5 Instruct base on the 15,960-pair titled
+   pool, chat-formatted, greedy decoding. The identical script trains the
+   7B (24GB GPU) and 72B (80GB GPU) variants; only `--base` changes.
+5. `infer_test.py` — greedy test-set inference producing the submission CSV.
+6. `validate_submission.py` — format gate: row count, column schema, no
+   empty predictions, length statistics.
+
+Run 1 (bart lineage) reproduces via the Kaggle kernels
+(`res-3-title-prefix`) recorded in the project artifacts.
+
+## Models
+
+- `Yakk99/scihigh2026-subtask1-qwen72b-qlora` — run-2 adapter (72B)
+- `Yakk99/scihigh2026-subtask1-qwen7b-qlora` — 7B pilot adapter
+- `Yakk99/scihigh2026-subtask1-bart-titled` — run-1 full model
+
+## Negative results (tested and closed, full logs in project artifacts)
+
+BRIO contrastive calibration (two decode-matched attempts, ~0 delta);
+MBR/DPO preference signal on the 72B pool (−2.0 — sampled candidates
+cluster below the greedy mode of a well-trained model); oracle bullet
+reordering (+0.0002); GRPO (rejected on published scientific-domain
+negatives); RAG (measured negative on this exact corpus by a FIRE-2025
+team).

final/build_datasets.py

@@ -0,0 +1,131 @@
+"""Build the final training/eval datasets.
+
+Stage 1 — repair: replace each accepted truncated abstract with its
+recovered text, normalized to the corpus format (the corpus strips all
+punctuation except periods; sentence-final periods are free-standing ' . '
+tokens; intra-token periods like '94.5' survive). The transform is
+validated against every accepted pair by comparing the normalized recovered
+prefix to the corpus text we already hold.
+
+Stage 2 — titles: prepend the paper title, `<title> | <abstract>`, applied
+identically to every split.
+
+Usage: python build_datasets.py
+Inputs: data/raw/*, data/external/{recovered_*,pii_title_cache.jsonl,*_with_pii.csv}
+Outputs: data/recovered/{train,train_expanded,val,test}[_titled].csv
+"""
+
+import json
+import re
+import unicodedata
+from difflib import SequenceMatcher
+from pathlib import Path
+
+import pandas as pd
+
+REPO = Path(__file__).resolve().parent.parent
+EXT = REPO / "data/external"
+OUT = REPO / "data/recovered"
+
+DASHES = "‐‑‒–—―−"
+SECTION_HEADERS = re.compile(
+    r"\b(BACKGROUND|METHODS?|RESULTS?|CONCLUSIONS?|OBJECTIVES?|PURPOSE"
+    r"|INTRODUCTION|RATIONALE|AIMS?|DISCUSSION|MATERIALS|SIGNIFICANCE"
+    r"|FINDINGS|INTERPRETATION|SETTING|DESIGN|PARTICIPANTS|MEASUREMENTS"
+    r"|LIMITATIONS|IMPLICATIONS|HYPOTHESIS|UNLABELLED|IMPORTANCE"
+    r"|EXPOSURES?|OUTCOMES?)(\s+AND\s+[A-Z]{4,})?\b[:.]?")
+
+
+def strip_to_corpus_format(text):
+    t = unicodedata.normalize("NFKC", str(text))
+    t = SECTION_HEADERS.sub("", t)
+    t = t.replace("!", ".").replace("?", ".")
+    t = re.sub(r"(?<=\S)\.(?=\S)", "\x00", t)
+    t = t.replace(".", " . ").replace("\x00", ".")
+    t = t.replace("-", " ")
+    for d in DASHES:
+        t = t.replace(d, "")
+    t = re.sub(r"[^A-Za-z0-9. ]", "", t)
+    return " ".join(t.split())
+
+
+def validate_transform():
+    scores = []
+    for split in ("train", "val", "test"):
+        rec = pd.read_csv(EXT / f"recovered_{split}.csv")
+        for _, r in rec[rec["accepted"]].iterrows():
+            a = str(r["Abstract"]).split()[:-2]
+            b = strip_to_corpus_format(r["RecoveredAbstract"]).split()[: len(a) + 20]
+            m = SequenceMatcher(None, a, b, autojunk=False)
+            scores.append(sum(bl.size for bl in m.get_matching_blocks()) / max(len(a), 1))
+    mean = sum(scores) / len(scores)
+    print(f"transform validation: {len(scores)} pairs, mean token agreement {mean:.4f}")
+    assert mean >= 0.90, "transform does not reproduce corpus format"
+
+
+def load_titles():
+    titles = {}
+    for line in (EXT / "pii_title_cache.jsonl").read_text().splitlines():
+        try:
+            r = json.loads(line)
+            if r.get("title"):
+                titles[r["pii"]] = r["title"]
+        except (json.JSONDecodeError, KeyError):
+            continue
+    return titles
+
+
+def clean_title(raw):
+    t = strip_to_corpus_format(raw)
+    while t.endswith(" ."):
+        t = t[:-2].rstrip()
+    return t
+
+
+def main():
+    validate_transform()
+    OUT.mkdir(exist_ok=True)
+    titles = load_titles()
+
+    repl = {}
+    for split in ("train", "val", "test"):
+        rec = pd.read_csv(EXT / f"recovered_{split}.csv")
+        acc = rec[rec["accepted"]]
+        for pii, a in zip(acc["PII"], acc["RecoveredAbstract"]):
+            repl[pii] = strip_to_corpus_format(a)
+    extra = EXT / "recovered_expanded_extra.csv"
+    if extra.exists():
+        rec = pd.read_csv(extra)
+        acc = rec[rec["accepted"]]
+        for pii, a in zip(acc["PII"], acc["RecoveredAbstract"]):
+            repl[pii] = strip_to_corpus_format(a)
+
+    pii_by_split = {
+        s: dict(zip(*(lambda d: (d["Filename"], d["PII"]))(
+            pd.read_csv(EXT / f"{s}_with_pii.csv"))))
+        for s in ("train", "val", "test")
+    }
+
+    for name in ("train", "val", "test", "train_expanded"):
+        df = pd.read_csv(REPO / f"data/raw/{name}.csv")
+        piis = (df["PaperID"] if name == "train_expanded"
+                else df["Filename"].map(pii_by_split[name.replace("_expanded", "")]))
+        df["Abstract"] = [repl.get(p, a) for p, a in zip(piis, df["Abstract"])]
+        df.to_csv(OUT / f"{name}.csv", index=False)
+
+        titled = []
+        for pii, ab in zip(piis, df["Abstract"]):
+            t = titles.get(pii)
+            titled.append(f"{clean_title(t)} | {ab}" if t else str(ab))
+        df_t = df.copy()
+        df_t["Abstract"] = titled
+        df_t.to_csv(OUT / f"{name}_titled.csv", index=False)
+
+        trunc = (~df["Abstract"].astype(str).str.rstrip().str.endswith(".")).mean()
+        print(f"{name}: {len(df)} rows, residual truncation {trunc:.1%}, "
+              f"titled variant written")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

final/fetch_titles.py

@@ -0,0 +1,77 @@
+"""Fetch paper titles for all corpus rows via the keyless Elsevier PII
+lookup. Titles are open bibliographic metadata and return for 100% of rows
+regardless of paywall status. Cache is append-only JSONL; resumable.
+
+Usage: python fetch_titles.py --splits val test expanded
+Outputs: data/external/pii_title_cache.jsonl
+"""
+
+import argparse
+import json
+import ssl
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+import certifi
+import pandas as pd
+
+REPO = Path(__file__).resolve().parent.parent
+CACHE = REPO / "data/external/pii_title_cache.jsonl"
+SSL_CTX = ssl.create_default_context(cafile=certifi.where())
+UA = "scihigh2026-titles"
+
+
+def fetch_title(pii):
+    req = urllib.request.Request(
+        f"https://api.elsevier.com/content/article/pii/{pii}",
+        headers={"User-Agent": UA, "Accept": "application/json"})
+    for attempt in range(4):
+        try:
+            with urllib.request.urlopen(req, timeout=45, context=SSL_CTX) as r:
+                d = json.loads(r.read())
+            return d["full-text-retrieval-response"]["coredata"].get("dc:title")
+        except urllib.error.HTTPError as e:
+            if e.code == 404:
+                return None
+            time.sleep(8 * (attempt + 1))
+        except Exception:
+            time.sleep(8 * (attempt + 1))
+    return None
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--splits", nargs="+", default=["val", "test", "expanded"])
+    args = ap.parse_args()
+
+    piis = []
+    for split in args.splits:
+        if split == "expanded":
+            piis += pd.read_csv(REPO / "data/raw/train_expanded.csv")["PaperID"].dropna().tolist()
+        else:
+            piis += pd.read_csv(REPO / f"data/external/{split}_with_pii.csv")["PII"].dropna().tolist()
+
+    cached = set()
+    if CACHE.exists():
+        for line in CACHE.read_text().splitlines():
+            try:
+                cached.add(json.loads(line)["pii"])
+            except (json.JSONDecodeError, KeyError):
+                continue
+    todo = [p for p in dict.fromkeys(piis) if p not in cached]
+    print(f"{len(piis)} rows requested, {len(todo)} to fetch")
+
+    with CACHE.open("a") as f:
+        for i, pii in enumerate(todo, 1):
+            f.write(json.dumps({"pii": pii, "title": fetch_title(pii)}) + "\n")
+            time.sleep(0.15)
+            if i % 500 == 0:
+                print(f"  {i}/{len(todo)}", flush=True)
+    print("done")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

final/infer_test.py

@@ -0,0 +1,95 @@
+"""Generate the test-set submission CSV from a trained Qwen adapter.
+
+Greedy decoding over `<title> | <abstract>` test inputs, output formatted as
+`Filename, Abstract, Predicted_Highlights` per the task specification. The
+Abstract column carries the OFFICIAL (unmodified) test abstracts.
+
+  python infer_test.py --base unsloth/Qwen2.5-72B-Instruct-bnb-4bit \\
+      --adapter qwen72_out/adapter --test-titled test_titled.csv \\
+      --test-official test.csv --out Yushkk99_Task1_run2.csv
+"""
+
+import argparse
+import subprocess
+import sys
+import time
+
+
+def pip(*p):
+    subprocess.run([sys.executable, "-m", "pip", "install", "-q", *p], check=True)
+
+
+pip("transformers>=4.51", "peft", "bitsandbytes", "pandas", "accelerate")
+
+import pandas as pd  # noqa: E402
+import torch  # noqa: E402
+from peft import PeftModel  # noqa: E402
+from transformers import (AutoModelForCausalLM, AutoTokenizer,  # noqa: E402
+                          BitsAndBytesConfig)
+
+SYS = ("You write research highlights. Given a paper title and abstract "
+       "(separated by |), produce 3-5 short highlight sentences in the exact "
+       "style of the examples you were trained on: no punctuation except "
+       "sentence-final periods written as ' . ', ~55 words total, each "
+       "sentence stating one contribution or finding.")
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--base", required=True)
+    ap.add_argument("--adapter", required=True)
+    ap.add_argument("--test-titled", required=True)
+    ap.add_argument("--test-official", required=True)
+    ap.add_argument("--out", default="submission.csv")
+    args = ap.parse_args()
+
+    tok = AutoTokenizer.from_pretrained(args.base)
+    model = AutoModelForCausalLM.from_pretrained(
+        args.base,
+        quantization_config=BitsAndBytesConfig(
+            load_in_4bit=True, bnb_4bit_quant_type="nf4",
+            bnb_4bit_compute_dtype=torch.bfloat16,
+            bnb_4bit_use_double_quant=True),
+        dtype=torch.bfloat16, device_map="auto")
+    model = PeftModel.from_pretrained(model, args.adapter)
+    model.eval()
+
+    titled = pd.read_csv(args.test_titled)
+    official = pd.read_csv(args.test_official)
+    preds = []
+    t0 = time.time()
+    with torch.no_grad():
+        for i in range(0, len(titled), 8):
+            batch = titled.iloc[i : i + 8]
+            prompts = [tok.apply_chat_template(
+                [{"role": "system", "content": SYS},
+                 {"role": "user", "content": str(a)}],
+                tokenize=False, add_generation_prompt=True)
+                for a in batch["Abstract"]]
+            enc = tok(prompts, return_tensors="pt", padding=True,
+                      truncation=True, max_length=1024,
+                      padding_side="left").to("cuda")
+            out = model.generate(**enc, max_new_tokens=130, do_sample=False,
+                                 pad_token_id=tok.pad_token_id)
+            preds += [tok.decode(out[j][enc.input_ids.shape[1]:],
+                                 skip_special_tokens=True).strip()
+                      for j in range(len(batch))]
+            if (i // 8) % 20 == 0:
+                rate = (i + len(batch)) / max(time.time() - t0, 1)
+                print(f"{i + len(batch)}/{len(titled)} "
+                      f"(eta {(len(titled) - i) / max(rate, 1e-9) / 60:.0f}m)",
+                      flush=True)
+
+    sub = pd.DataFrame({
+        "Filename": titled["Filename"],
+        "Abstract": official.set_index("Filename").loc[
+            titled["Filename"], "Abstract"].values,
+        "Predicted_Highlights": preds,
+    })
+    sub.to_csv(args.out, index=False)
+    print(f"wrote {args.out}: {len(sub)} rows")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

final/recover_abstracts.py

@@ -0,0 +1,174 @@
+"""Recover complete abstracts for truncated corpus rows.
+
+Chain: CSV row -> ScienceDirect PII (pre-verified join tables) -> DOI
+(keyless Elsevier Article API) -> abstract (Semantic Scholar /paper/batch).
+
+Acceptance filter (label-free): the recovered abstract must contain >=90%
+of the truncated text's content tokens, be strictly longer, and end in
+sentence-final punctuation. Both network stages checkpoint to JSONL caches,
+so the sweep is resumable.
+
+Usage: python recover_abstracts.py --splits val train test
+Inputs: data/external/{split}_with_pii.csv
+Outputs: data/external/recovered_{split}.csv
+"""
+
+import argparse
+import json
+import re
+import ssl
+import sys
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from pathlib import Path
+
+import certifi
+import pandas as pd
+
+REPO = Path(__file__).resolve().parent.parent
+EXT = REPO / "data/external"
+SSL_CTX = ssl.create_default_context(cafile=certifi.where())
+UA = "scihigh2026-recovery"
+SENTENCE_FINAL = (".", "!", "?")
+DOI_CACHE = EXT / "pii_doi_cache.jsonl"
+S2_CACHE = EXT / "s2_abstract_cache.jsonl"
+
+
+def is_truncated(text):
+    return not str(text).rstrip().endswith(SENTENCE_FINAL)
+
+
+def toks(t):
+    return re.findall(r"[a-z0-9]+", str(t).lower())
+
+
+def load_cache(path, key):
+    cache = {}
+    if path.exists():
+        for line in path.read_text().splitlines():
+            try:
+                rec = json.loads(line)
+                cache[rec[key]] = rec
+            except (json.JSONDecodeError, KeyError):
+                continue
+    return cache
+
+
+def append_cache(path, rec):
+    with path.open("a") as f:
+        f.write(json.dumps(rec) + "\n")
+
+
+def request_json(url, data=None, retries=6):
+    headers = {"User-Agent": UA, "Accept": "application/json"}
+    if data is not None:
+        headers["Content-Type"] = "application/json"
+    for attempt in range(retries):
+        req = urllib.request.Request(url, data=data, headers=headers)
+        try:
+            with urllib.request.urlopen(req, timeout=60, context=SSL_CTX) as r:
+                return json.loads(r.read())
+        except urllib.error.HTTPError as e:
+            if e.code in (404, 400):
+                return None
+            time.sleep(10 * (attempt + 1))
+        except Exception:
+            time.sleep(10 * (attempt + 1))
+    return None
+
+
+def resolve_dois(piis):
+    cache = load_cache(DOI_CACHE, "pii")
+    todo = [p for p in piis if p not in cache]
+    print(f"PII->DOI: {len(piis) - len(todo)} cached, {len(todo)} to resolve", flush=True)
+    for i, pii in enumerate(todo, 1):
+        d = request_json(f"https://api.elsevier.com/content/article/pii/{pii}", retries=3)
+        try:
+            doi = d["full-text-retrieval-response"]["coredata"]["prism:doi"]
+        except (KeyError, TypeError):
+            doi = None
+        rec = {"pii": pii, "doi": doi}
+        cache[pii] = rec
+        append_cache(DOI_CACHE, rec)
+        time.sleep(0.15)
+        if i % 500 == 0:
+            print(f"  {i}/{len(todo)}", flush=True)
+    return {p: cache[p]["doi"] for p in piis if p in cache}
+
+
+def fetch_s2(dois):
+    cache = load_cache(S2_CACHE, "doi")
+    todo = [d for d in dois if d not in cache]
+    print(f"S2 abstracts: {len(dois) - len(todo)} cached, {len(todo)} to fetch", flush=True)
+    for start in range(0, len(todo), 100):
+        chunk = todo[start : start + 100]
+        payload = json.dumps({"ids": [f"DOI:{d}" for d in chunk]}).encode()
+        res = request_json(
+            "https://api.semanticscholar.org/graph/v1/paper/batch?fields=abstract",
+            data=payload)
+        recs = res if isinstance(res, list) else [None] * len(chunk)
+        for doi, rec in zip(chunk, recs):
+            abstract = None
+            if isinstance(rec, dict) and rec.get("abstract"):
+                abstract = " ".join(rec["abstract"].split())
+            out = {"doi": doi, "abstract": abstract}
+            cache[doi] = out
+            append_cache(S2_CACHE, out)
+        time.sleep(3.0)
+    return {d: cache[d]["abstract"] for d in dois if d in cache}
+
+
+def accept(ours, theirs):
+    if not theirs:
+        return False, 0.0
+    cleaned = re.sub(r"^\s*Abstract\s+", "", theirs)
+    ours_t = toks(ours)
+    theirs_set = set(toks(cleaned))
+    cov = sum(1 for t in ours_t if t in theirs_set) / max(len(ours_t), 1)
+    ok = (cov >= 0.90
+          and len(cleaned) > len(str(ours)) * 1.05
+          and not is_truncated(cleaned))
+    return ok, cov
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--splits", nargs="+", default=["val", "train", "test"])
+    args = ap.parse_args()
+
+    frames = {}
+    all_piis = []
+    for split in args.splits:
+        df = pd.read_csv(EXT / f"{split}_with_pii.csv")
+        df = df[df["PII"].notna()].copy()
+        df["is_trunc"] = df["Abstract"].map(is_truncated)
+        frames[split] = df
+        all_piis += df.loc[df["is_trunc"], "PII"].tolist()
+
+    doi_map = resolve_dois(all_piis)
+    s2_map = fetch_s2(sorted({d for d in doi_map.values() if d}))
+
+    for split, df in frames.items():
+        recs = []
+        for _, r in df[df["is_trunc"]].iterrows():
+            doi = doi_map.get(r["PII"])
+            theirs = s2_map.get(doi) if doi else None
+            ok, cov = accept(r["Abstract"], theirs)
+            cleaned = re.sub(r"^\s*Abstract\s+", "", theirs) if theirs else None
+            recs.append({
+                "Filename": r["Filename"], "PII": r["PII"], "DOI": doi,
+                "Abstract": r["Abstract"],
+                "RecoveredAbstract": cleaned if ok else None,
+                "coverage": round(cov, 3), "accepted": ok,
+            })
+        out = pd.DataFrame(recs)
+        out.to_csv(EXT / f"recovered_{split}.csv", index=False)
+        print(f"{split}: {len(out)} truncated, {int(out['accepted'].sum())} "
+              f"accepted ({out['accepted'].mean():.1%})")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

final/train_qwen_qlora.py

@@ -0,0 +1,159 @@
+"""QLoRA supervised fine-tuning of a Qwen2.5 Instruct model for research
+highlight generation.
+
+Input rows: Abstract = `<title> | <repaired abstract>`, Highlights = target.
+4-bit NF4 base + LoRA (r=16, attention+MLP), bf16 compute, one epoch,
+chat-formatted. Evaluates plain ROUGE-L (stemmer=False) on a fixed
+stratified 300-row validation subset, then on full validation. Greedy
+decoding throughout. Self-contained: installs its own dependencies.
+
+  python train_qwen_qlora.py --train train_expanded_titled.csv \
+      --val val_titled.csv --base Qwen/Qwen2.5-72B-Instruct \
+      --batch 1 --accum 16 --out qwen72_out
+
+7B fits a 24GB GPU (--batch 4 --accum 4); 72B needs 80GB + ~150GB disk.
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+import time
+
+
+def pip(*pkgs):
+    subprocess.run([sys.executable, "-m", "pip", "install", "-q", *pkgs], check=True)
+
+
+pip("transformers>=4.51", "peft", "trl", "bitsandbytes", "datasets",
+    "rouge_score", "absl-py", "pandas", "accelerate")
+
+import numpy as np  # noqa: E402
+import pandas as pd  # noqa: E402
+import torch  # noqa: E402
+from datasets import Dataset  # noqa: E402
+from peft import LoraConfig  # noqa: E402
+from rouge_score import rouge_scorer  # noqa: E402
+from transformers import (AutoModelForCausalLM, AutoTokenizer,  # noqa: E402
+                          BitsAndBytesConfig)
+from trl import SFTConfig, SFTTrainer  # noqa: E402
+
+BASE = None  # set from --base
+SYS = ("You write research highlights. Given a paper title and abstract "
+       "(separated by |), produce 3-5 short highlight sentences in the exact "
+       "style of the examples you were trained on: no punctuation except "
+       "sentence-final periods written as ' . ', ~55 words total, each "
+       "sentence stating one contribution or finding.")
+SC = rouge_scorer.RougeScorer(["rougeL"], use_stemmer=False, split_summaries=False)
+
+
+def to_messages(row):
+    return {"messages": [
+        {"role": "system", "content": SYS},
+        {"role": "user", "content": str(row["Abstract"])},
+        {"role": "assistant", "content": str(row["Highlights"])},
+    ]}
+
+
+@torch.no_grad()
+def gen_eval(model, tok, df, label, save=None):
+    model.eval()
+    preds = []
+    t0 = time.time()
+    for i in range(0, len(df), 8):
+        batch = df.iloc[i : i + 8]
+        prompts = [tok.apply_chat_template(
+            [{"role": "system", "content": SYS},
+             {"role": "user", "content": str(a)}],
+            tokenize=False, add_generation_prompt=True) for a in batch["Abstract"]]
+        enc = tok(prompts, return_tensors="pt", padding=True,
+                  truncation=True, max_length=1024, padding_side="left").to("cuda")
+        out = model.generate(**enc, max_new_tokens=130, do_sample=False,
+                             pad_token_id=tok.pad_token_id)
+        for j in range(len(batch)):
+            text = tok.decode(out[j][enc.input_ids.shape[1]:],
+                              skip_special_tokens=True).strip()
+            preds.append(text)
+        if i == 0:
+            print(f"[{label}] sample pred: {preds[0][:200]!r}", flush=True)
+    scores = [SC.score(str(g), p)["rougeL"].fmeasure
+              for g, p in zip(df["Highlights"], preds)]
+    words = float(np.mean([len(p.split()) for p in preds]))
+    print(f"[{label}] rougeL={np.mean(scores):.4f}  words={words:.1f}  "
+          f"({time.time() - t0:.0f}s)", flush=True)
+    if save:
+        pd.DataFrame({"Filename": df["Filename"], "Prediction": preds,
+                      "rougeL": scores}).to_csv(save, index=False)
+    model.train()
+    return float(np.mean(scores))
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--train", required=True)
+    ap.add_argument("--val", required=True)
+    ap.add_argument("--out", default="qwen_out")
+    ap.add_argument("--base", default="Qwen/Qwen2.5-7B-Instruct")
+    ap.add_argument("--batch", type=int, default=4)
+    ap.add_argument("--accum", type=int, default=4)
+    args = ap.parse_args()
+    global BASE
+    BASE = args.base
+
+    train = pd.read_csv(args.train)
+    val = pd.read_csv(args.val)
+    trunc = ~val["Abstract"].astype(str).str.rstrip().str.endswith(".")
+    n_c = int(300 * (1 - trunc.mean()))
+    val_eval = pd.concat([
+        val[~trunc].sample(n=n_c, random_state=42),
+        val[trunc].sample(n=300 - n_c, random_state=42),
+    ]).reset_index(drop=True)
+
+    tok = AutoTokenizer.from_pretrained(BASE)
+    model = AutoModelForCausalLM.from_pretrained(
+        BASE,
+        quantization_config=BitsAndBytesConfig(
+            load_in_4bit=True, bnb_4bit_quant_type="nf4",
+            bnb_4bit_compute_dtype=torch.bfloat16,
+            bnb_4bit_use_double_quant=True),
+        dtype=torch.bfloat16, device_map="auto")
+
+    ds = Dataset.from_list([to_messages(r) for _, r in train.iterrows()])
+    peft_cfg = LoraConfig(
+        r=16, lora_alpha=32, lora_dropout=0.05, task_type="CAUSAL_LM",
+        target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
+                        "gate_proj", "up_proj", "down_proj"])
+    sft_cfg = SFTConfig(
+        output_dir=args.out, num_train_epochs=1,
+        per_device_train_batch_size=args.batch, gradient_accumulation_steps=args.accum,
+        learning_rate=2e-4, lr_scheduler_type="cosine", warmup_ratio=0.03,
+        bf16=True, logging_steps=50, save_strategy="no",
+        max_length=1024, gradient_checkpointing=True, report_to=[])
+    trainer = SFTTrainer(model=model, args=sft_cfg, train_dataset=ds,
+                         peft_config=peft_cfg, processing_class=tok)
+
+    print("=== pre-SFT zero-shot eval (30 rows, sanity) ===", flush=True)
+    gen_eval(trainer.model, tok, val_eval.head(30), "zero-shot")
+
+    trainer.train()
+    trainer.model.save_pretrained(f"{args.out}/adapter")
+    tok.save_pretrained(f"{args.out}/adapter")
+
+    print("=== post-SFT eval (300-row pinned subset) ===", flush=True)
+    subset = gen_eval(trainer.model, tok, val_eval, "post-sft-300",
+                      save=f"{args.out}/val300_predictions.csv")
+    full = None
+    if subset >= 0.25:
+        print("=== subset >= 0.25: full-val pass ===", flush=True)
+        full = gen_eval(trainer.model, tok, val, "post-sft-full",
+                        save=f"{args.out}/val_predictions.csv")
+    else:
+        print(f"subset {subset:.4f} < 0.25 -> kill-gate zone, skipping full val",
+              flush=True)
+    json.dump({"subset300": subset, "full_val": full},
+              open(f"{args.out}/result.json", "w"), indent=2)
+    print(f"DONE subset={subset:.4f} full={full}", flush=True)
+
+
+if __name__ == "__main__":
+    main()

final/validate_submission.py

@@ -0,0 +1,53 @@
+"""Format gate for a submission CSV. Checks row count against the official
+test split, column schema, empty/duplicate predictions, and length
+statistics. Exits non-zero on any hard failure.
+
+  python validate_submission.py --submission Yushkk99_Task1_run2.csv \\
+      --test data/raw/test.csv
+"""
+
+import argparse
+import sys
+
+import pandas as pd
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--submission", required=True)
+    ap.add_argument("--test", required=True)
+    args = ap.parse_args()
+
+    sub = pd.read_csv(args.submission)
+    test = pd.read_csv(args.test)
+    failures = []
+
+    if list(sub.columns) != ["Filename", "Abstract", "Predicted_Highlights"]:
+        failures.append(f"columns are {list(sub.columns)}")
+    if len(sub) != len(test):
+        failures.append(f"{len(sub)} rows, expected {len(test)}")
+    if set(sub["Filename"]) != set(test["Filename"]):
+        failures.append("Filename sets differ from official test split")
+    empty = sub["Predicted_Highlights"].isna() | (
+        sub["Predicted_Highlights"].astype(str).str.strip() == "")
+    if empty.any():
+        failures.append(f"{int(empty.sum())} empty predictions")
+
+    words = sub["Predicted_Highlights"].astype(str).str.split().str.len()
+    dupes = sub["Predicted_Highlights"].duplicated().sum()
+    print(f"rows: {len(sub)}")
+    print(f"prediction length: mean {words.mean():.1f} / min {words.min()} / "
+          f"max {words.max()} words")
+    print(f"duplicate predictions: {dupes}")
+
+    if failures:
+        print("\nFAIL:")
+        for f in failures:
+            print(f"  - {f}")
+        return 1
+    print("\nPASS: submission format is valid")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

train_final.ipynb

@@ -0,0 +1,274 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# SciHigh-2026 Subtask 1 \u2014 bart-large-cnn titled (run 1)\n",
+    "\n",
+    "Notebook version of `train_final.py` \u2014 run top to bottom.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\"\"\"\n",
+    "SciHigh-2026 Subtask 1 (Research Highlight Generation) -- final training recipe.\n",
+    "\n",
+    "Fine-tunes facebook/bart-large-cnn on the expanded MixSub-SciHigh training pool\n",
+    "to generate short research highlights from a paper's title and abstract.\n",
+    "Inputs are '<title> | <abstract>' with truncated abstracts repaired via\n",
+    "DOI-verified Semantic Scholar recovery (see final/ pipeline). This is the\n",
+    "exact recipe that produced the submitted result:\n",
+    "\n",
+    "    ROUGE-1=39.30%  ROUGE-2=15.32%  ROUGE-L=26.37%\n",
+    "    METEOR=36.17%   BERTScore-F1=88.05%\n",
+    "    (vs. the FIRE-2025 winning baseline of 23.45% ROUGE-L)\n",
+    "\n",
+    "This script is a clean, standalone extraction of the winning configuration --\n",
+    "it deliberately does NOT include the large space of experiments (backbone\n",
+    "sweeps, input-feature engineering, decode-time reranking/logit-bias/checkpoint\n",
+    "averaging, proxy-scale fast iteration mode, etc.) that were tried and used to\n",
+    "arrive at this recipe. Those all live in the project's internal experiment\n",
+    "history; none of them are part of what actually produced the result above.\n",
+    "\n",
+    "Usage:\n",
+    "    pip install torch transformers accelerate datasets evaluate rouge_score \\\n",
+    "        sentencepiece bert-score nltk\n",
+    "    python train_final.py --data_dir /path/to/data --output_dir ./output\n",
+    "\n",
+    "Expects --data_dir to contain:\n",
+    "    train_expanded_recovered_titled.csv  (15,960 rows: the\n",
+    "                          official 10,000-row MixSub-SciHigh train split plus\n",
+    "                          5,960 additional real pairs recovered from the\n",
+    "                          dataset's original source release, leakage-checked\n",
+    "                          against val/test by exact Abstract-text match)\n",
+    "    val_recovered_titled.csv (Filename, Abstract, Highlights -- 1,985 rows, the\n",
+    "                          official held-out validation split, used only for\n",
+    "                          per-epoch monitoring/checkpoint selection here)\n",
+    "    test_recovered_titled.csv (Filename, Abstract -- 1,840 rows, official masked\n",
+    "                          test split, for the submission predictions)\n",
+    "\"\"\"\n",
+    "import argparse\n",
+    "import json\n",
+    "import os\n",
+    "\n",
+    "import evaluate\n",
+    "import nltk\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import torch\n",
+    "from datasets import Dataset\n",
+    "from transformers import (\n",
+    "    AutoModelForSeq2SeqLM,\n",
+    "    AutoTokenizer,\n",
+    "    DataCollatorForSeq2Seq,\n",
+    "    EarlyStoppingCallback,\n",
+    "    Seq2SeqTrainer,\n",
+    "    Seq2SeqTrainingArguments,\n",
+    ")\n",
+    "\n",
+    "MODEL_NAME = \"facebook/bart-large-cnn\"\n",
+    "MAX_INPUT_LEN = 512\n",
+    "MAX_TARGET_LEN = 100  # matches the FIRE-2025 baseline recipe's output budget\n",
+    "BATCH_SIZE = 2\n",
+    "LEARNING_RATE = 2e-5\n",
+    "NUM_BEAMS = 4\n",
+    "\n",
+    "# Epoch ceiling, not a fixed schedule: bart-large-cnn converges fast on this\n",
+    "# task (a small-scale proxy run reached near-final quality in ~600-1,200\n",
+    "# gradient steps, a fraction of one full epoch's ~7,980 steps at batch_size=2\n",
+    "# over the 15,960-row pool). load_best_model_at_end + EarlyStoppingCallback\n",
+    "# below let the run self-terminate rather than committing to a fixed count.\n",
+    "# In the actual run that produced the reported numbers, training stopped\n",
+    "# after epoch 3 (2 consecutive non-improving epochs), and the checkpoint from\n",
+    "# epoch 1 -- the true best on val ROUGE-L -- was the one restored and\n",
+    "# evaluated/submitted.\n",
+    "EPOCH_CEILING = 4\n",
+    "EARLY_STOPPING_PATIENCE = 2\n",
+    "\n",
+    "for _pkg in [\"wordnet\", \"punkt_tab\", \"omw-1.4\"]:\n",
+    "    try:\n",
+    "        nltk.download(_pkg, quiet=True)\n",
+    "    except Exception as e:  # noqa: BLE001\n",
+    "        print(f\"warning: failed to download nltk resource '{_pkg}': {e}\")\n",
+    "\n",
+    "\n",
+    "def parse_args():\n",
+    "    p = argparse.ArgumentParser()\n",
+    "    p.add_argument(\"--data_dir\", required=True)\n",
+    "    p.add_argument(\"--output_dir\", default=\"output\")\n",
+    "    p.add_argument(\"--epochs\", type=int, default=EPOCH_CEILING)\n",
+    "    p.add_argument(\"--skip_bertscore\", action=\"store_true\", help=\"BERTScore eval downloads its own scoring model; skip for a fast local check\")\n",
+    "    return p.parse_args()\n",
+    "\n",
+    "\n",
+    "def to_hf_dataset(df, has_target):\n",
+    "    d = {\"Abstract\": df[\"Abstract\"].tolist()}\n",
+    "    if has_target:\n",
+    "        d[\"Highlights\"] = df[\"Highlights\"].tolist()\n",
+    "    return Dataset.from_dict(d)\n",
+    "\n",
+    "\n",
+    "def make_preprocess_fn(tokenizer):\n",
+    "    def preprocess(batch):\n",
+    "        model_inputs = tokenizer(batch[\"Abstract\"], max_length=MAX_INPUT_LEN, truncation=True)\n",
+    "        labels = tokenizer(text_target=batch[\"Highlights\"], max_length=MAX_TARGET_LEN, truncation=True)\n",
+    "        model_inputs[\"labels\"] = labels[\"input_ids\"]\n",
+    "        return model_inputs\n",
+    "\n",
+    "    return preprocess\n",
+    "\n",
+    "\n",
+    "def main():\n",
+    "    args = parse_args()\n",
+    "    os.makedirs(args.output_dir, exist_ok=True)\n",
+    "    device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+    "\n",
+    "    train_df = pd.read_csv(os.path.join(args.data_dir, \"train_expanded_recovered_titled.csv\"))\n",
+    "    val_df = pd.read_csv(os.path.join(args.data_dir, \"val_recovered_titled.csv\"))\n",
+    "    test_df = pd.read_csv(os.path.join(args.data_dir, \"test_recovered_titled.csv\"))\n",
+    "    print(f\"[train_final] device={device} train={len(train_df)} val={len(val_df)} test={len(test_df)}\")\n",
+    "\n",
+    "    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)\n",
+    "    model = AutoModelForSeq2SeqLM.from_pretrained(MODEL_NAME).to(device)\n",
+    "\n",
+    "    # Decode-time settings: bart-large-cnn already ships no_repeat_ngram_size=3\n",
+    "    # in its own generation_config, but it's set explicitly here rather than\n",
+    "    # left implicit, so the decision doesn't silently depend on that shipped\n",
+    "    # default surviving a future transformers/model-card change. Two other\n",
+    "    # settings that were tuned during small-scale proxy experiments\n",
+    "    # (repetition_penalty=1.5, min_new_tokens=15) were fixes for degenerate\n",
+    "    # repetition-collapse in a severely undertrained checkpoint -- this\n",
+    "    # full-scale, fully-converged model doesn't exhibit that failure mode, so\n",
+    "    # those are deliberately left untouched at bart-large-cnn's own defaults\n",
+    "    # (repetition_penalty=1.0, min_length=56) rather than carried over.\n",
+    "    model.generation_config.no_repeat_ngram_size = 3\n",
+    "    model.generation_config.max_length = MAX_TARGET_LEN\n",
+    "\n",
+    "    train_ds = to_hf_dataset(train_df, has_target=True)\n",
+    "    val_ds = to_hf_dataset(val_df, has_target=True)\n",
+    "    preprocess = make_preprocess_fn(tokenizer)\n",
+    "    train_tok = train_ds.map(preprocess, batched=True, remove_columns=train_ds.column_names)\n",
+    "    val_tok = val_ds.map(preprocess, batched=True, remove_columns=val_ds.column_names)\n",
+    "    collator = DataCollatorForSeq2Seq(tokenizer, model=model)\n",
+    "\n",
+    "    rouge = evaluate.load(\"rouge\")\n",
+    "    meteor = evaluate.load(\"meteor\")\n",
+    "\n",
+    "    def compute_metrics(eval_preds):\n",
+    "        preds, labels = eval_preds\n",
+    "        if isinstance(preds, tuple):\n",
+    "            preds = preds[0]\n",
+    "        preds = np.where(preds != -100, preds, tokenizer.pad_token_id)\n",
+    "        decoded_preds = tokenizer.batch_decode(preds, skip_special_tokens=True)\n",
+    "        labels = np.where(labels != -100, labels, tokenizer.pad_token_id)\n",
+    "        decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True)\n",
+    "\n",
+    "        result = rouge.compute(predictions=decoded_preds, references=decoded_labels)\n",
+    "        result = {f\"rouge_{k}\": v for k, v in result.items()}\n",
+    "        result[\"meteor\"] = meteor.compute(predictions=decoded_preds, references=decoded_labels)[\"meteor\"]\n",
+    "        return result\n",
+    "\n",
+    "    training_args = Seq2SeqTrainingArguments(\n",
+    "        output_dir=os.path.join(args.output_dir, \"checkpoints\"),\n",
+    "        num_train_epochs=args.epochs,\n",
+    "        per_device_train_batch_size=BATCH_SIZE,\n",
+    "        per_device_eval_batch_size=BATCH_SIZE,\n",
+    "        learning_rate=LEARNING_RATE,\n",
+    "        label_smoothing_factor=0.0,\n",
+    "        warmup_ratio=0.0,\n",
+    "        # Adafactor's factored second-moment estimates avoid the full-size\n",
+    "        # exp_avg/exp_avg_sq buffers that OOM'd a 16GB T4 with plain Adam; it's\n",
+    "        # also what the original PEGASUS/BART pretraining used.\n",
+    "        optim=\"adafactor\",\n",
+    "        predict_with_generate=True,\n",
+    "        generation_max_length=MAX_TARGET_LEN,\n",
+    "        generation_num_beams=NUM_BEAMS,\n",
+    "        eval_strategy=\"epoch\",\n",
+    "        save_strategy=\"epoch\",\n",
+    "        save_total_limit=1,\n",
+    "        load_best_model_at_end=True,\n",
+    "        metric_for_best_model=\"rouge_rougeL\",\n",
+    "        fp16=(device == \"cuda\"),\n",
+    "        logging_steps=50,\n",
+    "        report_to=[],\n",
+    "    )\n",
+    "\n",
+    "    trainer = Seq2SeqTrainer(\n",
+    "        model=model,\n",
+    "        args=training_args,\n",
+    "        train_dataset=train_tok,\n",
+    "        eval_dataset=val_tok,\n",
+    "        data_collator=collator,\n",
+    "        compute_metrics=compute_metrics,\n",
+    "        callbacks=[EarlyStoppingCallback(early_stopping_patience=EARLY_STOPPING_PATIENCE)],\n",
+    "    )\n",
+    "\n",
+    "    trainer.train()\n",
+    "\n",
+    "    final_model_dir = os.path.join(args.output_dir, \"model\")\n",
+    "    trainer.save_model(final_model_dir)\n",
+    "    tokenizer.save_pretrained(final_model_dir)\n",
+    "\n",
+    "    val_metrics = trainer.evaluate()\n",
+    "    print(\"[train_final] validation metrics:\", val_metrics)\n",
+    "\n",
+    "    if not args.skip_bertscore:\n",
+    "        from bert_score import score as bertscore\n",
+    "\n",
+    "        val_preds = trainer.predict(val_tok)\n",
+    "        preds = np.where(val_preds.predictions != -100, val_preds.predictions, tokenizer.pad_token_id)\n",
+    "        decoded_preds = tokenizer.batch_decode(preds, skip_special_tokens=True)\n",
+    "        _, _, f1 = bertscore(decoded_preds, val_df[\"Highlights\"].tolist(), lang=\"en\", verbose=False)\n",
+    "        val_metrics[\"bertscore_f1\"] = float(f1.mean())\n",
+    "        print(\"[train_final] bertscore_f1:\", val_metrics[\"bertscore_f1\"])\n",
+    "\n",
+    "    with open(os.path.join(args.output_dir, \"val_metrics.json\"), \"w\") as f:\n",
+    "        json.dump(val_metrics, f, indent=2)\n",
+    "\n",
+    "    # Generate the submission predictions on the masked test set.\n",
+    "    model.eval()\n",
+    "    gen_device = next(model.parameters()).device\n",
+    "    predictions = []\n",
+    "    batch_size = max(BATCH_SIZE, 8)\n",
+    "    abstracts = test_df[\"Abstract\"].tolist()\n",
+    "    for i in range(0, len(abstracts), batch_size):\n",
+    "        batch = abstracts[i : i + batch_size]\n",
+    "        inputs = tokenizer(batch, max_length=MAX_INPUT_LEN, truncation=True, padding=True, return_tensors=\"pt\").to(gen_device)\n",
+    "        with torch.no_grad():\n",
+    "            generated = model.generate(**inputs, max_length=MAX_TARGET_LEN, num_beams=NUM_BEAMS)\n",
+    "        predictions.extend(tokenizer.batch_decode(generated, skip_special_tokens=True))\n",
+    "\n",
+    "    submission = pd.DataFrame({\n",
+    "        \"Filename\": test_df[\"Filename\"],\n",
+    "        \"Abstract\": test_df[\"Abstract\"],\n",
+    "        \"Predicted_Highlights\": predictions,\n",
+    "    })\n",
+    "    submission_path = os.path.join(args.output_dir, \"Yushkk99_Task1_run1.csv\")\n",
+    "    submission.to_csv(submission_path, index=False)\n",
+    "    print(f\"[train_final] wrote submission to {submission_path}\")\n",
+    "\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    main()\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

train_final.py

@@ -0,0 +1,240 @@
+"""
+SciHigh-2026 Subtask 1 (Research Highlight Generation) -- final training recipe.
+
+Fine-tunes facebook/bart-large-cnn on the expanded MixSub-SciHigh training pool
+to generate short research highlights from a paper's title and abstract.
+Inputs are '<title> | <abstract>' with truncated abstracts repaired via
+DOI-verified Semantic Scholar recovery (see final/ pipeline). This is the
+exact recipe that produced the submitted result:
+
+    ROUGE-1=39.30%  ROUGE-2=15.32%  ROUGE-L=26.37%
+    METEOR=36.17%   BERTScore-F1=88.05%
+    (vs. the FIRE-2025 winning baseline of 23.45% ROUGE-L)
+
+This script is a clean, standalone extraction of the winning configuration --
+it deliberately does NOT include the large space of experiments (backbone
+sweeps, input-feature engineering, decode-time reranking/logit-bias/checkpoint
+averaging, proxy-scale fast iteration mode, etc.) that were tried and used to
+arrive at this recipe. Those all live in the project's internal experiment
+history; none of them are part of what actually produced the result above.
+
+Usage:
+    pip install torch transformers accelerate datasets evaluate rouge_score \
+        sentencepiece bert-score nltk
+    python train_final.py --data_dir /path/to/data --output_dir ./output
+
+Expects --data_dir to contain:
+    train_expanded_recovered_titled.csv  (15,960 rows: the
+                          official 10,000-row MixSub-SciHigh train split plus
+                          5,960 additional real pairs recovered from the
+                          dataset's original source release, leakage-checked
+                          against val/test by exact Abstract-text match)
+    val_recovered_titled.csv (Filename, Abstract, Highlights -- 1,985 rows, the
+                          official held-out validation split, used only for
+                          per-epoch monitoring/checkpoint selection here)
+    test_recovered_titled.csv (Filename, Abstract -- 1,840 rows, official masked
+                          test split, for the submission predictions)
+"""
+import argparse
+import json
+import os
+
+import evaluate
+import nltk
+import numpy as np
+import pandas as pd
+import torch
+from datasets import Dataset
+from transformers import (
+    AutoModelForSeq2SeqLM,
+    AutoTokenizer,
+    DataCollatorForSeq2Seq,
+    EarlyStoppingCallback,
+    Seq2SeqTrainer,
+    Seq2SeqTrainingArguments,
+)
+
+MODEL_NAME = "facebook/bart-large-cnn"
+MAX_INPUT_LEN = 512
+MAX_TARGET_LEN = 100  # matches the FIRE-2025 baseline recipe's output budget
+BATCH_SIZE = 2
+LEARNING_RATE = 2e-5
+NUM_BEAMS = 4
+
+# Epoch ceiling, not a fixed schedule: bart-large-cnn converges fast on this
+# task (a small-scale proxy run reached near-final quality in ~600-1,200
+# gradient steps, a fraction of one full epoch's ~7,980 steps at batch_size=2
+# over the 15,960-row pool). load_best_model_at_end + EarlyStoppingCallback
+# below let the run self-terminate rather than committing to a fixed count.
+# In the actual run that produced the reported numbers, training stopped
+# after epoch 3 (2 consecutive non-improving epochs), and the checkpoint from
+# epoch 1 -- the true best on val ROUGE-L -- was the one restored and
+# evaluated/submitted.
+EPOCH_CEILING = 4
+EARLY_STOPPING_PATIENCE = 2
+
+for _pkg in ["wordnet", "punkt_tab", "omw-1.4"]:
+    try:
+        nltk.download(_pkg, quiet=True)
+    except Exception as e:  # noqa: BLE001
+        print(f"warning: failed to download nltk resource '{_pkg}': {e}")
+
+
+def parse_args():
+    p = argparse.ArgumentParser()
+    p.add_argument("--data_dir", required=True)
+    p.add_argument("--output_dir", default="output")
+    p.add_argument("--epochs", type=int, default=EPOCH_CEILING)
+    p.add_argument("--skip_bertscore", action="store_true", help="BERTScore eval downloads its own scoring model; skip for a fast local check")
+    return p.parse_args()
+
+
+def to_hf_dataset(df, has_target):
+    d = {"Abstract": df["Abstract"].tolist()}
+    if has_target:
+        d["Highlights"] = df["Highlights"].tolist()
+    return Dataset.from_dict(d)
+
+
+def make_preprocess_fn(tokenizer):
+    def preprocess(batch):
+        model_inputs = tokenizer(batch["Abstract"], max_length=MAX_INPUT_LEN, truncation=True)
+        labels = tokenizer(text_target=batch["Highlights"], max_length=MAX_TARGET_LEN, truncation=True)
+        model_inputs["labels"] = labels["input_ids"]
+        return model_inputs
+
+    return preprocess
+
+
+def main():
+    args = parse_args()
+    os.makedirs(args.output_dir, exist_ok=True)
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+
+    train_df = pd.read_csv(os.path.join(args.data_dir, "train_expanded_recovered_titled.csv"))
+    val_df = pd.read_csv(os.path.join(args.data_dir, "val_recovered_titled.csv"))
+    test_df = pd.read_csv(os.path.join(args.data_dir, "test_recovered_titled.csv"))
+    print(f"[train_final] device={device} train={len(train_df)} val={len(val_df)} test={len(test_df)}")
+
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+    model = AutoModelForSeq2SeqLM.from_pretrained(MODEL_NAME).to(device)
+
+    # Decode-time settings: bart-large-cnn already ships no_repeat_ngram_size=3
+    # in its own generation_config, but it's set explicitly here rather than
+    # left implicit, so the decision doesn't silently depend on that shipped
+    # default surviving a future transformers/model-card change. Two other
+    # settings that were tuned during small-scale proxy experiments
+    # (repetition_penalty=1.5, min_new_tokens=15) were fixes for degenerate
+    # repetition-collapse in a severely undertrained checkpoint -- this
+    # full-scale, fully-converged model doesn't exhibit that failure mode, so
+    # those are deliberately left untouched at bart-large-cnn's own defaults
+    # (repetition_penalty=1.0, min_length=56) rather than carried over.
+    model.generation_config.no_repeat_ngram_size = 3
+    model.generation_config.max_length = MAX_TARGET_LEN
+
+    train_ds = to_hf_dataset(train_df, has_target=True)
+    val_ds = to_hf_dataset(val_df, has_target=True)
+    preprocess = make_preprocess_fn(tokenizer)
+    train_tok = train_ds.map(preprocess, batched=True, remove_columns=train_ds.column_names)
+    val_tok = val_ds.map(preprocess, batched=True, remove_columns=val_ds.column_names)
+    collator = DataCollatorForSeq2Seq(tokenizer, model=model)
+
+    rouge = evaluate.load("rouge")
+    meteor = evaluate.load("meteor")
+
+    def compute_metrics(eval_preds):
+        preds, labels = eval_preds
+        if isinstance(preds, tuple):
+            preds = preds[0]
+        preds = np.where(preds != -100, preds, tokenizer.pad_token_id)
+        decoded_preds = tokenizer.batch_decode(preds, skip_special_tokens=True)
+        labels = np.where(labels != -100, labels, tokenizer.pad_token_id)
+        decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True)
+
+        result = rouge.compute(predictions=decoded_preds, references=decoded_labels)
+        result = {f"rouge_{k}": v for k, v in result.items()}
+        result["meteor"] = meteor.compute(predictions=decoded_preds, references=decoded_labels)["meteor"]
+        return result
+
+    training_args = Seq2SeqTrainingArguments(
+        output_dir=os.path.join(args.output_dir, "checkpoints"),
+        num_train_epochs=args.epochs,
+        per_device_train_batch_size=BATCH_SIZE,
+        per_device_eval_batch_size=BATCH_SIZE,
+        learning_rate=LEARNING_RATE,
+        label_smoothing_factor=0.0,
+        warmup_ratio=0.0,
+        # Adafactor's factored second-moment estimates avoid the full-size
+        # exp_avg/exp_avg_sq buffers that OOM'd a 16GB T4 with plain Adam; it's
+        # also what the original PEGASUS/BART pretraining used.
+        optim="adafactor",
+        predict_with_generate=True,
+        generation_max_length=MAX_TARGET_LEN,
+        generation_num_beams=NUM_BEAMS,
+        eval_strategy="epoch",
+        save_strategy="epoch",
+        save_total_limit=1,
+        load_best_model_at_end=True,
+        metric_for_best_model="rouge_rougeL",
+        fp16=(device == "cuda"),
+        logging_steps=50,
+        report_to=[],
+    )
+
+    trainer = Seq2SeqTrainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_tok,
+        eval_dataset=val_tok,
+        data_collator=collator,
+        compute_metrics=compute_metrics,
+        callbacks=[EarlyStoppingCallback(early_stopping_patience=EARLY_STOPPING_PATIENCE)],
+    )
+
+    trainer.train()
+
+    final_model_dir = os.path.join(args.output_dir, "model")
+    trainer.save_model(final_model_dir)
+    tokenizer.save_pretrained(final_model_dir)
+
+    val_metrics = trainer.evaluate()
+    print("[train_final] validation metrics:", val_metrics)
+
+    if not args.skip_bertscore:
+        from bert_score import score as bertscore
+
+        val_preds = trainer.predict(val_tok)
+        preds = np.where(val_preds.predictions != -100, val_preds.predictions, tokenizer.pad_token_id)
+        decoded_preds = tokenizer.batch_decode(preds, skip_special_tokens=True)
+        _, _, f1 = bertscore(decoded_preds, val_df["Highlights"].tolist(), lang="en", verbose=False)
+        val_metrics["bertscore_f1"] = float(f1.mean())
+        print("[train_final] bertscore_f1:", val_metrics["bertscore_f1"])
+
+    with open(os.path.join(args.output_dir, "val_metrics.json"), "w") as f:
+        json.dump(val_metrics, f, indent=2)
+
+    # Generate the submission predictions on the masked test set.
+    model.eval()
+    gen_device = next(model.parameters()).device
+    predictions = []
+    batch_size = max(BATCH_SIZE, 8)
+    abstracts = test_df["Abstract"].tolist()
+    for i in range(0, len(abstracts), batch_size):
+        batch = abstracts[i : i + batch_size]
+        inputs = tokenizer(batch, max_length=MAX_INPUT_LEN, truncation=True, padding=True, return_tensors="pt").to(gen_device)
+        with torch.no_grad():
+            generated = model.generate(**inputs, max_length=MAX_TARGET_LEN, num_beams=NUM_BEAMS)
+        predictions.extend(tokenizer.batch_decode(generated, skip_special_tokens=True))
+
+    submission = pd.DataFrame({
+        "Filename": test_df["Filename"],
+        "Abstract": test_df["Abstract"],
+        "Predicted_Highlights": predictions,
+    })
+    submission_path = os.path.join(args.output_dir, "Yushkk99_Task1_run1.csv")
+    submission.to_csv(submission_path, index=False)
+    print(f"[train_final] wrote submission to {submission_path}")
+
+
+if __name__ == "__main__":
+    main()