RERBOT

Datasets

Every dataset ERBOT runs on — where it comes from, how it is structured, how its gold standard was built, who else has used it, and what analysing the data itself showed. Provenance is stated per dataset; where a source or a licence is not established, the page says so instead of smoothing it over. ERBOT links to the original sources rather than redistributing data it has no licence to share.

Short on time? The three experiment datasets tell the story: Cora (real headroom), D10K (total saturation; JedAI’s Febrl-generated synthetic), MusicBrainz 20K (near-ceiling, generator-built).

Cora (citation deduplication)

ERBOT experiments · Studio
Source.
Citation records from the Cora research-paper search engine (McCallum et al.), distributed through the RIDDLE repository (UT Austin), provided by William Cohen. Not the graph-ML “Cora” dataset — same origin system, different data.
Scale.
1,879 citation records, 182 gold clusters (verified against our copy).
Fields.
16 segmented citation fields: title, booktitle, authors, address, date, year, editor, journal, volume, pages, publisher, institution, type, tech, note — plus the gold label.
Gold standard.
Hand-labelled citation clusters shipped with the RIDDLE distribution; ERBOT stores them as a duplicate-pair list (id1, id2).
Who used it.
A benchmark since Bilenko & Mooney (KDD 2003, “Adaptive Duplicate Detection Using Learnable String Similarity Measures”). In ERBOT it is the hard case of the E1/E2 blocking experiments (2026).
What the data taught us.
Famously dirty: fields bleed into each other, values arrive fragmented (a “title” cell can hold half a citation), many cells are empty. In our blocking experiments a plain per-record kNN baseline reaches only PC = 0.59–0.71 here — the one dataset in our matrix with real headroom, and the one where marginal budget allocation shows a permutation-certified gain (+0.32 PC, p = 0.005).

D10K (synthetic, 10,000 records)

ERBOT experiments · Studio · JedAI benchmark
Source.
The synthetic Dirty-ER dataset D10K from the JedAI benchmark suite (Papadakis et al., “Three-dimensional Entity Resolution with JedAI,” Information Systems 93, 2020). Census-style person profiles artificially generated with the Febrl generator: duplicate-free profiles were first built from frequency tables of real given names, surnames and addresses, then duplicates were created with realistic error modifications (character/word insertions, deletions, substitutions; at most 10 per entity), leaving 40% of the records duplicates. Our copy is a flattened re-packaging of JedAI’s serialized profiles (single Aggregate Value column, plus embedding columns we do not use), obtained through a university lab’s dataset collection — whose bundled data README is the JedAI dataset description itself. The fingerprint matches on every number: 10,000 profiles, 12 attributes, 8,705 duplicate pairs, and the 40%-duplicate rate implies 6,000 distinct entities — all verified on our copy (the pair file has exactly 8,705 rows and yields exactly 8,705 true pairs).
Scale.
10,000 records, 6,000 entities, 8,705 duplicate pairs (JedAI, Table 1 of the paper above; all counts verified on our copy).
Fields.
12 person attributes in the original (names, addresses and related census-style values; 106,108 name–value pairs in total). Our copy (10Kfull.csv) is pipe-delimited and already flattened when it reached the lab that shared it with us: every attribute is concatenated into the single Aggregate Value string (a record reads like '41 molly 31 batlow 19390609 6050 bishop 08 29028996 qld 4676841 daley crescent'). The file's other columns are a cleaned copy of that string and two embedding columns — the 12-attribute structure was never restored, and every method run on this data treats the record as a bag of words. ERBOT loads only Id and the Aggregate Value text.
Gold standard.
Known by construction (Febrl generation). Our copy carries it as a pair file (10Kduplicates.csv, Entity1|Entity2) of generation links; clusters are the connected components of those pairs. A task-type note, because the name misleads: Febrl is a record-linkage system, but its generator emits a single originals-plus-duplicates table, and JedAI benchmarks these sets as Dirty ER — deduplication within one collection. Our copy has exactly that layout: one table, one id space, no source column.
Who used it.
The JedAI experimental programme (Papadakis et al. 2020 and the blocking/filtering evaluations around it) uses D10K as the smallest of a synthetic scale ladder (D10K–D2M). In ERBOT it is the ceiling case of the E1/E2 full-protocol matrix (2026), below.
What the data taught us.
Duplicates are near-identical synthetic copies inside one long text field, so a plain per-record kNN baseline saturates: baseline PC = 1.0000 at k = 50 (reduction ratio 0.977), and neither collective blocking nor marginal allocation has any headroom left. We audited the pipeline for truth leakage before reporting this — gold labels touch only the entity-disjoint split, train-side tuning and final scoring, never the similarity computation — and a dedicated data-side audit (cluster-signature tokens, id-in-text, gold-pair cosine distribution) accompanies the experiment code. D10K’s role in the paper is to mark the scope boundary: budget-allocation questions only exist where the baseline cannot saturate.

MusicBrainz 20K

ERBOT experiments · Studio
Source.
Leipzig University Database Group, Benchmark datasets for entity resolution; introduced with the FAMER multi-source matching framework (Saeedi, Peukert & Rahm). Distributed under a Creative Commons licence (Leipzig DB Group, June 2019).
Scale.
Official 20K release: 19,375 records from 5 sources, 10,000 clusters, 16,250 duplicate pairs. The family scales by 10× steps up to a 20M variant (19,375,000 records, 10,000,000 clusters, 16,250,000 pairs).
Fields.
Raw header (verified on our file): TID, CID, CTID, SourceID, id, number, title, length, artist, album, year, language. Values are messy by design — lengths like “1m 58sec”, years like “75” or “null”.
Gold standard.
Known by construction: real MusicBrainz records were duplicated and corrupted with the DAPO / GeCo data generators, so the cluster id (CID) is the gold standard.
Who used it.
FAMER and later multi-source clustering evaluations; also Databricks’ Arc Autolinker evaluation (a 10× scaled variant). In ERBOT: the near-ceiling column of the E1/E2 matrix — our local raw file is Leipzig’s 20M variant (19,375,000 records, 10,000,000 clusters, 16,250,000 pairs — all three counts match the Leipzig table exactly), from which we sample whole CID clusters down to 20,000 records (10,294 entities).
What the data taught us.
Baseline pair completeness is already 0.9954, so both of our methods are kill-line dead here — yet the learned allocation still beats a random allocation under permutation (p = 0.005): the ordering effect is real, the headroom is not. The Gollum gold-standard paper (arXiv:2209.07479) cautions that generator-built datasets “can be arbitrarily large but do not represent real-world matching problems” — we report MusicBrainz results with that caveat attached.

Abt-Buy

Studio · Leipzig benchmark
Source.
Product records scraped from the online retailers Abt.com and Buy.com for Köpcke, Thor & Rahm, “Evaluation of entity resolution approaches on real-world match problems” (PVLDB 2010); distributed via the Leipzig benchmark page under a Creative Commons licence (Leipzig DB Group, Jan 2019).
Scale.
2,173 records (1,081 Abt + 1,092 Buy), 1,076 entities in our Studio copy, 1,097 gold matches.
Fields.
id, source, name, description, manufacturer, price. Mostly free text — descriptions carry the matching signal.
Gold standard.
Derived from UPC codes: only products with a valid UPC were kept, and identical UPC = match (per Köpcke et al. 2010).
Who used it.
One of the most-used entity-matching benchmarks since 2010: the FEVER evaluations, DeepMatcher’s textual category, Ditto and essentially every later EM paper. Ships in ERBOT Studio as a ready-made demo.
What the data taught us.
A two-source linkage task with highly textual attributes and little structure to exploit — a good middle-difficulty test between the toy restaurant sample and Cora.

Affiliation strings

Studio · Leipzig benchmark
Source.
Leipzig University Database Group, Benchmark datasets for entity resolution, under a Creative Commons licence (June 2019). The strings were extracted from the PDFs of database publications that appeared between 2000 and 2009.
Scale.
2,260 affiliation strings, 330 gold clusters, 32,816 within-cluster pairs.
Fields.
Exactly one attribute: the affiliation string itself, as extracted from publications.
Gold standard.
Strings grouped by the institution they refer to.
Who used it.
Tabulated in the Gollum gold-standard survey (arXiv:2209.07479) as the single-attribute clustering case; ships in ERBOT Studio.
What the data taught us.
No attribute structure at all — one noisy free-text field with abbreviations, reordered components and missing pieces. A pure string-clustering problem, and a useful stress test for similarity functions.

Fodors–Zagats (Restaurant)

Package · DeepMatcher / RIDDLE
Source.
Restaurant records from the Fodor’s and Zagat’s guides. The original Restaurant dataset (Sheila Tejada) was distributed via RIDDLE; the two-table packaging is the DeepMatcher benchmark’s.
Scale.
864 source records with 112 duplicates (RIDDLE distribution); DeepMatcher packaging: 946 labelled pairs, 110 positives. ERBOT Studio ships a 35-record toy sample.
Fields.
ERBOT keeps id, source, name, addr, city, phone, type.
Gold standard.
The duplicate labels shipped with the RIDDLE Restaurant distribution; ERBOT’s builder turns the DeepMatcher matches file into (id, cluster_id) gold.
Who used it.
In use since the early 2000s (Tejada’s own work, MARLIN-era evaluations); a standard “small data” test in the DeepMatcher family, where several models reach F1 = 1.0.
What the data taught us.
Tiny and largely solved — which is exactly its job in ERBOT: a smoke test where any pipeline regression shows up immediately.

DBLP–ACM

Package · DeepMatcher
Source.
Bibliographic records from DBLP and the ACM Digital Library, first presented by Köpcke & Rahm (2008); the Leipzig distribution is Creative Commons (Jan 2019). Labelled train/validation/test splits packaged by DeepMatcher (Mudgal et al., SIGMOD 2018, UW–Madison).
Scale.
2,614 DBLP + 2,294 ACM records, 2,224 gold matches.
Fields.
authors, title, venue, year.
Gold standard.
Built on the partially hand-curated source data; the sibling DBLP–Scholar perfect-match result was determined manually (Köpcke et al. 2010).
Who used it.
A staple structured-matching benchmark (DeepMatcher, Ditto, and most EM papers since 2010). ERBOT ships a builder (er_build_dblp_acm()) that merges the two tables into ERBOT’s combined format.
What the data taught us.
Considered one of the easier benchmarks — Köpcke et al. expected “low difficulty”, and modern methods routinely reach F1 ≈ 0.98. Useful as a sanity floor, not as a discriminator.

North Carolina Voter Registration (NCVR)

Package · scale track
Source.
Three different artifacts share this name; we keep them apart. (a) Raw snapshots published free by the NC State Board of Elections (NCSBE). (b) Peter Christen’s (ANU) temporal merge of 17 snapshots, 2011–2014 (technical report, 2014). (c) The generated large-scale test dataset of Panse et al., EDBT 2021 (paper). (d) Leipzig’s generated “North Carolina Voters” family (benchmark page, Creative Commons, June 2019): real registry records replicated across 5 or 10 duplicate-free sources with GeCo — 50% of entities replicated in all sources uncorrupted, 25% corrupted and replicated everywhere, 25% corrupted and present in only some sources, at a moderate 20% corruption rate; the 5-source configuration holds 5,000,000 records in 3,500,840 clusters.
Scale.
Christen’s merge: ~8.26M records over ~8.1M voters — ~98% of voters have one record, ~145,000 have two, ~3,500 have three to six. Panse et al. generated >120M labelled records from 45 snapshots. Raw records carry ~90 attributes (incl. the NCID).
Fields.
Names, addresses, age, gender, driver’s licence and telephone numbers, race, ethnicity, party affiliation (~70 attributes in Christen’s files; ~90 incl. district/election fields in the raw snapshots).
Gold standard.
The voter registration number (NCID/VRN) identifies the voter — with Christen’s explicit caveat that it is “not 100% correct”.
Who used it.
Christen’s record-linkage research programme; Panse et al.’s large-scale duplicate-detection testbed; a ~100K Leipzig NC sample in Databricks’ Autolinker evaluation. In ERBOT it is the designated scale track: the design samples whole NCID clusters up a 100K → full ladder to test blocking where the small benchmarks saturate.
What the data taught us.
Real, dirty and temporal: forms are re-collected by hand each election, so typos, swapped fields and outdated values accumulate — and Christen’s report documents a severely corrupted April 2014 snapshot. This is the dataset family where our small-benchmark scope conclusions (allocation matters only without saturation) go to be stress-tested.

Sources