File size: 9,648 Bytes
4d72966
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
a121d73
 
4d72966
 
 
 
2260979
 
 
 
 
 
 
 
 
 
 
 
 
4d72966
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
af56a7d
 
 
 
4d72966
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
af56a7d
 
4d72966
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
"""
Abstractive highlight generators for the demo, both guarded by a fact check.

  LLMRewriter        a small instruction-tuned LLM (default Qwen/Qwen2.5-1.5B-Instruct, Apache-2.0) rewrites the
                     abstract into short highlights, guided by the sentences the extractive model picked
  FineTunedSummarizer  a seq2seq model fine-tuned on MixSub (see SciHigh_2026_Abstractive_FineTune.ipynb),
                     loaded from the Hugging Face Hub once it has been trained

fact_check() rejects a generated highlight when it contains a number that is not in the abstract, or when
too many of its content words do not occur in the abstract. Rejected highlights are replaced by the
Concise (compressed extractive) highlight for the same position, so the output never contains an
unsupported number.
"""
import os, re, threading, time
import numpy as np

LLM_ID = os.environ.get("SCIHIGH_LLM", "Qwen/Qwen2.5-1.5B-Instruct")
FT_ID = os.environ.get("SCIHIGH_FINETUNED", "Akash212/scihigh-bart-base")

_STOP = set("""a about above after again against all also am among an and any are as at be because been before being
below between both but by can could did do does doing during each few for from further had has have having he her
here him his how i if in into is it its itself more most no nor not now of off on once only or other our out over
own same she should so some such than that the their them then there these they this those through to too under
until up very was we were what when where which while who whom why will with would you your study paper work
research results result findings approach method methods proposed propose novel new using used use based show
shows shown highlight highlights without within across among while whereas however therefore thus including
including across towards toward upon also both either neither like""".split())
_NUM = re.compile(r"\d+(?:\.\d+)?")
_W = re.compile(r"[a-z][a-z\-]+")


try:
    from nltk.stem.porter import PorterStemmer
    _PS = PorterStemmer()
    def _stem(w):
        return _PS.stem(w.lower().strip("-"))
except Exception:                                   # crude fallback if nltk is missing
    def _stem(w):
        w = w.lower().strip("-")
        for suf in ("ational", "ization", "isation", "ingly", "edly", "ments", "ment", "ness", "ities", "ity", "ings",
                    "ing", "ies", "ied", "ers", "er", "ed", "es", "s", "al", "ly", "y"):
            if len(w) > len(suf) + 3 and w.endswith(suf):
                return w[:-len(suf)]
        return w


def fact_check(highlight, source, max_novel=0.34):
    """(ok, reason). A highlight fails if it has a number absent from the source, or if more than
    `max_novel` of its content words (compared by stem, hyphenated parts included) are absent from the source."""
    src = source.lower()
    for n in _NUM.findall(highlight):
        if n not in src:
            return False, f"number {n} is not in the abstract"
    src_stems = {_stem(p) for w in _W.findall(src) for p in [w] + w.split("-")}
    # names, datasets and acronyms must come from the abstract (an acronym may abbreviate a phrase in it)
    src_words = re.findall(r"[a-z0-9]+", src)
    initials = {"".join(x[0] for x in src_words[i:i + n]) for n in range(2, 6) for i in range(len(src_words) - n + 1)}
    for i, t in enumerate(re.findall(r"[A-Za-z][A-Za-z0-9\-]*", highlight)):
        if i == 0 or not (t[0].isupper() or sum(c.isupper() for c in t) >= 2): continue
        tl = t.lower()
        if tl in src or _stem(tl) in src_stems: continue
        acro = re.sub(r"s$", "", t) if t[:-1].isupper() else t
        if acro.isupper() and acro.lower() in initials: continue
        return False, f"name or acronym '{t}' is not in the abstract"
    words = [w for w in _W.findall(highlight.lower()) if w not in _STOP and len(w) > 3]
    if not words:
        return True, ""
    novel = [w for w in words if _stem(w) not in src_stems and not all(_stem(p) in src_stems for p in w.split("-") if p)]
    if len(novel) / len(words) > max_novel:
        return False, "words not in the abstract: " + ", ".join(novel[:5])
    return True, ""


def parse_bullets(text, k):
    out = []
    for line in text.splitlines():
        line = re.sub(r"^\s*(?:[-*•]|\d+[.)])\s*", "", line).strip()
        line = re.sub(r"^(?:highlight\s*\d*\s*[:.-])\s*", "", line, flags=re.I).strip()
        line = re.sub(r"^\*\*[^*]{1,40}\*\*\s*:?\s*", "", line).strip()          # "**Findings:** ..."
        line = re.sub(r"^(?:problem|background|method|methods|approach|objective|aim|findings?|results?|implications?|"
                      r"conclusions?|contribution)\s*:\s*", "", line, flags=re.I).strip()
        line = line.replace("**", "").strip()
        if len(line.split()) >= 4 and not line.lower().startswith(("here are", "highlights", "sure")):
            out.append(line.rstrip(".") + ".")
    return out[:k]


def guarded(generated, fallback, source):
    """Apply fact_check to each generated highlight; replace failures with the fallback highlight in that slot."""
    rows = []
    for i, h in enumerate(generated):
        ok, why = fact_check(h, source)
        if ok:
            rows.append((h, "generated", ""))
        else:
            fb = fallback[i] if i < len(fallback) else None
            if fb: rows.append((fb.rstrip(".") + ".", "fallback (concise)", why))
    if not rows:
        rows = [(f.rstrip(".") + ".", "fallback (concise)", "no usable generated highlight") for f in fallback]
    return rows


class _Lazy:
    """Loads a model in a background thread so the app starts immediately."""

    def __init__(self):
        self.model = self.tok = None; self.error = None; self._t = None; self.load_seconds = None

    def start(self):
        if self._t is None:
            self._t = threading.Thread(target=self._safe_load, daemon=True); self._t.start()
        return self

    def _safe_load(self):
        t = time.time()
        try: self._load()
        except Exception as e: self.error = f"{type(e).__name__}: {e}"
        self.load_seconds = round(time.time() - t, 1)

    def ready(self, wait=0):
        self.start()
        if wait: self._t.join(timeout=wait)
        return self.model is not None


class LLMRewriter(_Lazy):
    def __init__(self, model_id=LLM_ID):
        super().__init__(); self.model_id = model_id

    def _load(self):
        import torch
        from transformers import AutoTokenizer, AutoModelForCausalLM
        torch.set_num_threads(max(1, os.cpu_count() or 1))
        self.tok = AutoTokenizer.from_pretrained(self.model_id)
        self.model = AutoModelForCausalLM.from_pretrained(self.model_id, dtype=torch.float32).eval()

    def generate(self, abstract, key_sentences, k=3, max_words=20):
        import torch
        keys = "\n".join(f"- {s}" for s in key_sentences)
        prompt = (f"Abstract:\n{abstract.strip()}\n\nMost important sentences (chosen by an extractive model):\n{keys}\n\n"
                  f"Write exactly {k} research highlights for this abstract.\n"
                  f"Rules:\n- One highlight per line, starting with \"- \".\n"
                  f"- Each highlight is one short sentence of at most {max_words} words.\n"
                  "- Summarise and rephrase; do not copy whole sentences.\n"
                  "- Cover the problem, the method and the main finding or aim.\n"
                  "- Use only facts stated in the abstract. Do not add numbers, names, datasets or claims that are not in it.\n"
                  "- Keep the authors' certainty: if the abstract only aims, proposes or evaluates something, do not state it as a result.\n"
                  "- Plain sentences only: no title, no introduction, no labels, no bold text, no numbering.")
        msgs = [{"role": "system", "content": "You write concise, faithful research highlights for scientific papers."},
                {"role": "user", "content": prompt}]
        ids = self.tok.apply_chat_template(msgs, add_generation_prompt=True, return_tensors="pt", return_dict=True)
        with torch.no_grad():
            out = self.model.generate(**ids, max_new_tokens=40 * k, do_sample=False, repetition_penalty=1.05,
                                      pad_token_id=self.tok.eos_token_id)
        text = self.tok.decode(out[0][ids["input_ids"].shape[-1]:], skip_special_tokens=True)
        return parse_bullets(text, k), text


class FineTunedSummarizer(_Lazy):
    def __init__(self, model_id=FT_ID):
        super().__init__(); self.model_id = model_id

    def _load(self):
        import torch
        from huggingface_hub import repo_exists
        if not os.path.isdir(self.model_id) and not repo_exists(self.model_id):
            raise FileNotFoundError(f"{self.model_id} does not exist yet. Train it with the fine-tuning notebook first.")
        from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
        torch.set_num_threads(max(1, os.cpu_count() or 1))
        self.tok = AutoTokenizer.from_pretrained(self.model_id)
        self.model = AutoModelForSeq2SeqLM.from_pretrained(self.model_id).eval()

    def generate(self, abstract, k=None):
        import torch
        ids = self.tok(abstract, return_tensors="pt", truncation=True, max_length=512)
        with torch.no_grad():
            out = self.model.generate(**ids, max_new_tokens=128, num_beams=4, no_repeat_ngram_size=3, early_stopping=True)
        text = self.tok.decode(out[0], skip_special_tokens=True)
        parts = [p.strip() for p in re.split(r"(?<=[a-z0-9\)%])\.\s+", text) if len(p.split()) >= 3]
        return [p.rstrip(".") + "." for p in parts][: (k or len(parts))], text