Spaces:
Running on Zero
Running on Zero
Download generators.py from Akash212/Highlight_Generator: direct link, hf CLI and curl.
- Browser
- Download file 9.65 kB
-
https://huggingface.co/spaces/Akash212/Highlight_Generator/resolve/main/generators.py
- Command line
-
hf download hf://spaces/Akash212/Highlight_Generator/generators.py
-
curl -L -o generators.py https://huggingface.co/spaces/Akash212/Highlight_Generator/resolve/main/generators.py
9.65 kB
| """ | |
| 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 | |