| """Score HyperAPI's Extract endpoint on hyperbots-inc/synthetic-invoice-extraction. |
| |
| Setup: |
| # install the HyperAPI SDK: https://apis.hyperbots.com/docs/quickstart |
| export HYPERAPI_KEY=hk_test_... # free key: https://apis.hyperbots.com/dashboard/api-keys |
| |
| Run: |
| python evaluate_hyperapi.py --limit 25 # score 25 invoices (uses the OCR text as a .txt upload) |
| python evaluate_hyperapi.py --limit 25 --pdf # render the HTML to PDF first (needs: pip install weasyprint) |
| python evaluate_hyperapi.py --dry-run # check the scoring pipeline with gold labels, no API calls |
| |
| The free tier covers 30 pages per month, so keep --limit at or below 30 on a free key. |
| """ |
| import argparse |
| import json |
| import os |
| import re |
| import tempfile |
| from datetime import datetime |
|
|
| CORE_FIELDS = ["invoice_number", "date", "due_date", "vendor_name", "total_amount", "currency"] |
| DATE_FORMATS = ["%Y-%m-%d", "%m/%d/%Y", "%d/%m/%Y", "%b %d, %Y", "%d %B %Y", "%B %d, %Y", "%d-%m-%Y", "%Y/%m/%d"] |
|
|
|
|
| def load_rows(path=None): |
| if path is None: |
| from huggingface_hub import hf_hub_download |
| path = hf_hub_download("hyperbots-inc/synthetic-invoice-extraction", "data/test.jsonl", repo_type="dataset") |
| with open(path, encoding="utf-8") as f: |
| return [json.loads(line) for line in f if line.strip()] |
|
|
|
|
| def norm_text(x): |
| return re.sub(r"\s+", " ", str(x or "")).strip().lower().rstrip(".") |
|
|
|
|
| def norm_amount(x): |
| if x is None: |
| return None |
| s = re.sub(r"[^0-9.\-]", "", str(x).replace(",", "")) |
| try: |
| return round(float(s), 2) |
| except ValueError: |
| return None |
|
|
|
|
| def norm_date(x, hint=None): |
| s = str(x or "").strip() |
| fmts = DATE_FORMATS |
| if hint == "eu": |
| fmts = ["%d/%m/%Y"] + [f for f in DATE_FORMATS if f != "%d/%m/%Y"] |
| for f in fmts: |
| try: |
| return datetime.strptime(s, f).strftime("%Y-%m-%d") |
| except ValueError: |
| continue |
| return s |
|
|
|
|
| def field_match(name, pred, gold, row): |
| if name in ("total_amount",): |
| return norm_amount(pred) is not None and norm_amount(pred) == norm_amount(gold) |
| if name in ("date", "due_date"): |
| return norm_date(pred, row.get("date_format")) == gold |
| return norm_text(pred) == norm_text(gold) |
|
|
|
|
| def line_items_match(pred_items, gold_items): |
| """Fraction of gold line items whose total appears among predicted line totals.""" |
| pred_totals = [norm_amount(i.get("total") or i.get("amount")) for i in (pred_items or [])] |
| hits = 0 |
| for g in gold_items: |
| t = norm_amount(g["total"]) |
| if t in pred_totals: |
| pred_totals.remove(t) |
| hits += 1 |
| return hits / max(len(gold_items), 1) |
|
|
|
|
| def to_file(row, tmpdir, as_pdf): |
| if as_pdf: |
| from weasyprint import HTML |
| path = os.path.join(tmpdir, row["id"] + ".pdf") |
| HTML(string=row["html"]).write_pdf(path) |
| else: |
| path = os.path.join(tmpdir, row["id"] + ".txt") |
| with open(path, "w", encoding="utf-8") as f: |
| f.write(row["ocr_text"]) |
| return path |
|
|
|
|
| def predict(client, path): |
| res = client.extract(path) |
| result = res.get("result", res) if isinstance(res, dict) else {} |
| return result.get("entities", {}), result.get("line_items", []) |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--limit", type=int, default=25) |
| ap.add_argument("--pdf", action="store_true", help="render HTML to PDF before upload (needs weasyprint)") |
| ap.add_argument("--data", default=None, help="local path to test.jsonl (default: download from the Hub)") |
| ap.add_argument("--dry-run", action="store_true", help="score gold labels against themselves; no API calls") |
| args = ap.parse_args() |
|
|
| rows = load_rows(args.data)[: args.limit] |
| client = None |
| if not args.dry_run: |
| from hyperapi import HyperAPIClient |
| client = HyperAPIClient() |
|
|
| hits = {f: 0 for f in CORE_FIELDS} |
| li_scores = [] |
| with tempfile.TemporaryDirectory() as tmp: |
| for row in rows: |
| gold = row["labels"] |
| if args.dry_run: |
| ents, items = gold["entities"], gold["line_items"] |
| else: |
| ents, items = predict(client, to_file(row, tmp, args.pdf)) |
| for f in CORE_FIELDS: |
| hits[f] += field_match(f, ents.get(f), gold["entities"][f], row) |
| li_scores.append(line_items_match(items, gold["line_items"])) |
| if client is not None: |
| client.close() |
|
|
| n = len(rows) |
| print(f"Scored {n} invoices") |
| for f in CORE_FIELDS: |
| print(f" {f:<16} {hits[f] / n:6.1%}") |
| print(f" {'line_items':<16} {sum(li_scores) / n:6.1%} (share of gold line totals recovered)") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
