Datasets:
File size: 6,770 Bytes
7f9a652 | 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 | """Score predictions against Lilambd Empire Eval.
usage: python score.py --qa data/ --pred predictions.jsonl [--out score.json] [--lenient]
predictions.jsonl: one JSON object per line: {"id": "...", "answer": <value or string>}
- numbers may be given as strings with commas or a trailing unit ("1,234 km2")
- lists may be a JSON list or a comma/semicolon separated string
- to abstain, answer null, "" or a phrase like "not in the dataset" / "unknown"
Metrics:
accuracy share of all questions answered correctly (missing = wrong)
answerable_accuracy accuracy on questions that have an answer
abstention_accuracy share of unanswerable questions where the system abstained
hallucination_rate share of unanswerable questions where it gave an answer anyway
false_abstention share of answerable questions where it abstained
Breakdowns by dataset, task, difficulty and skill.
"""
import argparse, collections, glob, json, math, os, re, sys, unicodedata
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from package import unflat
ABSTAIN = re.compile(r"^(?:null|none|n/?a|unknown|not (in|available|found|present|recorded|listed)|no (data|record|row|answer|such)|cannot (be )?(determin\w*|answer\w*|find\w*)|can't|insufficient|unanswerable|the (dataset|data|ledger|table) (does not|doesn't|has no))(?:\b|$)", re.I)
def norm_s(x):
s = unicodedata.normalize('NFKD', str(x))
s = ''.join(c for c in s if not unicodedata.combining(c)).casefold()
s = re.sub(r'[\s_]+', ' ', s)
s = re.sub(r"[\"'`.,;:!?()\[\]{}]", '', s).strip()
return s
def parse_num(x):
if isinstance(x, bool):
return None
if isinstance(x, (int, float)):
return float(x)
m = re.search(r'[-+−]?\d[\d,]*(?:\.\d+)?(?:[eE][-+]?\d+)?|[-+−]?\.\d+', str(x).replace(' ', '').replace(' ', ''))
if not m:
return None
return float(m.group(0).replace(',', '').replace('−', '-'))
def parse_list(x):
if isinstance(x, list):
return [norm_s(v) for v in x]
s = str(x).strip()
if s.startswith('['):
try:
return [norm_s(v) for v in json.loads(s)]
except json.JSONDecodeError:
pass
return [norm_s(v) for v in re.split(r'[;,\n]|\s\|\s', s) if v.strip()]
def is_abstain(x):
if x is None:
return True
if isinstance(x, str) and (not x.strip() or ABSTAIN.match(x.strip())):
return True
return False
def correct(item, pred, lenient=False):
t = item['answer_type']
gold = item['answer']
if t == 'none':
return is_abstain(pred)
if is_abstain(pred):
return False
if t == 'number':
p = parse_num(pred)
if p is None or math.isnan(p):
return False
tol = item.get('tolerance', {'rel': 0.01})
if 'abs' in tol:
return abs(p - gold) <= tol['abs'] + 1e-9
return abs(p - gold) <= tol['rel'] * max(abs(gold), 1e-12)
if t == 'boolean':
s = norm_s(pred)
v = True if s in ('true', 'yes', 'y', '1') else False if s in ('false', 'no', 'n', '0') else None
return v is not None and v == gold
if t == 'list_ordered':
return parse_list(pred) == [norm_s(v) for v in gold]
if t == 'list_set':
return set(parse_list(pred)) == {norm_s(v) for v in gold}
g, p = norm_s(gold), norm_s(pred)
if g == p:
return True
if isinstance(gold, (int, float)) or re.fullmatch(r'-?\d+(\.\d+)?', g):
try:
gn = float(gold)
except (TypeError, ValueError): # e.g. a code like '111.242.222' that only looks numeric after normalising
return False
pn = parse_num(pred)
return pn is not None and abs(pn - gn) < 1e-9
if lenient:
return re.search(r'(^|\W)' + re.escape(g) + r'($|\W)', p) is not None
return False
def main():
ap = argparse.ArgumentParser()
ap.add_argument('--qa', required=True, help='folder with *.jsonl or one jsonl file')
ap.add_argument('--pred', required=True)
ap.add_argument('--out', default=None)
ap.add_argument('--lenient', action='store_true', help='string answers may be embedded in a longer reply')
a = ap.parse_args()
files = sorted(glob.glob(os.path.join(a.qa, '*.jsonl')) + glob.glob(os.path.join(a.qa, 'data', '*.jsonl'))) if os.path.isdir(a.qa) else [a.qa]
items = [unflat(json.loads(l)) for f in files for l in open(f, encoding='utf-8')]
items = [it for it in items if 'answer' in it] # question-only test rows are scored by the maintainer
preds = {}
for l in open(a.pred, encoding='utf-8'):
if l.strip():
o = json.loads(l)
preds[o['id']] = o.get('answer', o.get('prediction'))
agg = collections.defaultdict(lambda: [0, 0])
unans = [0, 0, 0] # n, abstained, answered
ansd = [0, 0] # n, abstained
for it in items:
has = it['id'] in preds
p = preds.get(it['id'], '__missing__')
ok = has and correct(it, p, a.lenient)
keys = ['all', 'dataset:' + it['dataset'], 'task:' + it['task'], f"difficulty:{it['difficulty']}"] + ['skill:' + s for s in it.get('skills', [])]
for k in keys:
agg[k][0] += 1
agg[k][1] += ok
if it['answer_type'] == 'none':
unans[0] += 1
if has and is_abstain(p):
unans[1] += 1
elif has:
unans[2] += 1
else:
ansd[0] += 1
if has and is_abstain(p):
ansd[1] += 1
res = {k: {'n': v[0], 'correct': v[1], 'accuracy': round(v[1] / v[0], 4)} for k, v in sorted(agg.items())}
summary = {
'questions': len(items), 'predicted': sum(1 for it in items if it['id'] in preds),
'accuracy': res['all']['accuracy'],
'answerable_accuracy': round(sum(1 for it in items if it['answer_type'] != 'none' and it['id'] in preds and correct(it, preds[it['id']], a.lenient)) / max(1, ansd[0]), 4),
'abstention_accuracy': round(unans[1] / max(1, unans[0]), 4),
'hallucination_rate': round(unans[2] / max(1, unans[0]), 4),
'false_abstention': round(ansd[1] / max(1, ansd[0]), 4),
}
out = {'summary': summary, 'breakdown': res}
print(json.dumps(summary, indent=1))
print('\n| slice | n | accuracy |\n|---|---|---|')
for k, v in res.items():
if k.startswith(('dataset:', 'task:', 'difficulty:')) or k == 'all':
print(f"| {k} | {v['n']} | {v['accuracy']:.3f} |")
if a.out:
json.dump(out, open(a.out, 'w'), indent=1)
if __name__ == '__main__':
main()
|