Download code/features.py from Vijayarv07/grounding-checker: direct link, hf CLI and curl.
- Browser
- Download file 5.16 kB
-
https://huggingface.co/datasets/Vijayarv07/grounding-checker/resolve/main/code/features.py
- Command line
-
hf download hf://datasets/Vijayarv07/grounding-checker/code/features.py
-
curl -L -o features.py https://huggingface.co/datasets/Vijayarv07/grounding-checker/resolve/main/code/features.py
5.16 kB
| """Per-claim grounding features. Deliberately classical so they re-implement cleanly in JS. | |
| The claim is scored against the source using lexical support signals: | |
| overlap, fuzzy match, number/entity support, novel-content ratio, and a contradiction signal. | |
| """ | |
| from __future__ import annotations | |
| import re | |
| STOP = set("a an the of to in on at for and or but with by from as is are was were be been being " | |
| "it its this that these those they them their he she his her you your we our i me my " | |
| "has have had do does did will would can could should may might must not no " | |
| "about over under into out up down off than then so such also just only very more most " | |
| "which who whom whose what when where why how".split()) | |
| NEG = set("not no never none cannot can't don't doesn't didn't won't isn't aren't wasn't weren't " | |
| "without fell dropped declined fewer less lower nothing failed".split()) | |
| FEATURE_NAMES = [ | |
| "tok_jaccard_doc", "tok_recall_doc", "best_sent_jaccard", "best_sent_recall", | |
| "fuzzy_best", "fuzzy_doc", "number_support", "entity_support", "novel_content_ratio", | |
| "contradiction_signal", "has_number", "has_entity", "claim_len_tokens", "n_source_sents", | |
| ] | |
| def sentences(text: str): | |
| return [s.strip() for s in re.split(r"(?<=[.!?])\s+", text.strip()) if s.strip()] | |
| def content_tokens(text: str): | |
| toks = re.findall(r"[a-z0-9]+", text.lower()) | |
| return [t for t in toks if t not in STOP and len(t) > 1] | |
| def numbers(text: str): | |
| # standalone integers / decimals, ignoring those glued inside words | |
| return set(re.findall(r"(?<![A-Za-z])\d+(?:\.\d+)?", text)) | |
| NUM_WORDS = {"one": "1", "two": "2", "three": "3", "four": "4", "five": "5", "six": "6", | |
| "seven": "7", "eight": "8", "nine": "9", "ten": "10"} | |
| def numbers_norm(text: str): | |
| nums = set(numbers(text)) | |
| for w, d in NUM_WORDS.items(): | |
| if re.search(rf"\b{w}\b", text.lower()): | |
| nums.add(d) | |
| return nums | |
| def entities(text: str): | |
| # capitalized spans not at sentence start only — approx proper nouns; keep multiword + single | |
| spans = re.findall(r"\b([A-Z][a-zA-Z]+(?:\s+[A-Z][a-zA-Z]+)*)\b", text) | |
| out = set() | |
| for s in spans: | |
| for w in s.split(): | |
| if w.lower() not in STOP: | |
| out.add(w.lower()) | |
| return out | |
| def _jaccard(a: set, b: set) -> float: | |
| if not a and not b: | |
| return 0.0 | |
| return len(a & b) / len(a | b) if (a | b) else 0.0 | |
| def _recall(a: set, b: set) -> float: | |
| # fraction of a's tokens present in b | |
| return len(a & b) / len(a) if a else 0.0 | |
| def _bigrams(s: str): | |
| s = s.lower() | |
| return [s[i:i+2] for i in range(len(s) - 1)] | |
| def _fuzzy(a: str, b: str) -> float: | |
| # char-bigram Dice coefficient; deterministic and trivially portable to JS | |
| A, B = _bigrams(a), _bigrams(b) | |
| if not A or not B: | |
| return 0.0 | |
| from collections import Counter | |
| ca, cb = Counter(A), Counter(B) | |
| inter = sum((ca & cb).values()) | |
| return 2 * inter / (len(A) + len(B)) | |
| def features(claim: str, source: str) -> list[float]: | |
| src_sents = sentences(source) | |
| claim_tok = set(content_tokens(claim)) | |
| doc_tok = set(content_tokens(source)) | |
| f = [] | |
| f.append(_jaccard(claim_tok, doc_tok)) # tok_jaccard_doc | |
| f.append(_recall(claim_tok, doc_tok)) # tok_recall_doc | |
| best_j = best_r = 0.0 | |
| best_fuzzy = 0.0 | |
| best_sent = "" | |
| for s in src_sents: | |
| st = set(content_tokens(s)) | |
| j = _jaccard(claim_tok, st) | |
| r = _recall(claim_tok, st) | |
| if r > best_r or (r == best_r and j > best_j): | |
| best_r, best_j, best_sent = r, j, s | |
| best_fuzzy = max(best_fuzzy, _fuzzy(claim, s)) | |
| f.append(best_j) # best_sent_jaccard | |
| f.append(best_r) # best_sent_recall | |
| f.append(best_fuzzy) # fuzzy_best | |
| f.append(_fuzzy(claim, source)) # fuzzy_doc | |
| cnums, dnums = numbers_norm(claim), numbers_norm(source) | |
| f.append(1.0 if not cnums else len(cnums & dnums) / len(cnums)) # number_support | |
| cent, dent = entities(claim), entities(source) | |
| f.append(1.0 if not cent else len(cent & dent) / len(cent)) # entity_support | |
| f.append(1.0 - _recall(claim_tok, doc_tok)) # novel_content_ratio | |
| # contradiction: claim has a negation token that its best-match source sentence lacks (or vice-versa) | |
| claim_neg = bool(set(re.findall(r"[a-z']+", claim.lower())) & NEG) | |
| best_neg = bool(set(re.findall(r"[a-z']+", best_sent.lower())) & NEG) | |
| f.append(1.0 if claim_neg != best_neg else 0.0) # contradiction_signal | |
| f.append(1.0 if cnums else 0.0) # has_number | |
| f.append(1.0 if cent else 0.0) # has_entity | |
| f.append(float(len(claim_tok))) # claim_len_tokens | |
| f.append(float(len(src_sents))) # n_source_sents | |
| return f | |