rishavk77/amc26-entity-resolution-embeddings

AMC26 — Business Entity Resolution Embeddings (multilingual-e5-base)

Precomputed sentence embeddings for the Amazon ML Challenge 2026 business entity-resolution task. Vectors cover the full training split and exist only to power blocking / candidate retrieval: for each Source 1 business, find the handful of Source 2 / Source 3 records that might be the same business.

Embedding the 12.5M records is the expensive, tedious part of this task. These files let you skip it and go straight to ranking and decisioning.

What is here

file	rows	shape	dtype	size
emb_s1_full_name_addr.npy	2,206,821	(2206821, 768)	float16	3.16 GiB
emb_s1_full_name.npy	2,206,821	(2206821, 768)	float16	3.16 GiB
emb_s1_full_addr.npy	2,206,821	(2206821, 768)	float16	3.16 GiB
emb_pool_full_name_addr.npy	10,320,219	(10320219, 768)	float16	14.76 GiB
emb_pool_full_name.npy	10,320,219	(10320219, 768)	float16	14.76 GiB
emb_pool_full_addr.npy	10,320,219	(10320219, 768)	float16	14.76 GiB
index_s1.parquet	2,206,821	—	—	0.16 GiB
index_pool.parquet	10,320,219	—	—	0.76 GiB

Total: 54.68 GB (≈50.9 GiB).

Source 2 and Source 3 are pooled into one table (*_pool_*) in a single row order. Distinguish them by the entity_id prefix (S2-… vs S3-…) in index_pool.parquet.

Three channels

A channel is one independent embedding pass over different input text. All three are provided because their union recovers far more true pairs than any one alone.

channel suffix	input string fed to the model
_name	"query: " + name_raw
_addr	"query: " + addr_norm
_name_addr	"query: " + name_raw + " | " + addr_norm

• name_raw is the original script-preserving name (accents, Devanagari intact) — a multilingual encoder can use that signal, whereas transliteration destroys it.
• addr_norm is a normalized address (lowercased, punctuation stripped, whitespace collapsed, transliterated to ASCII).
• The literal "query: " prefix is required by the e5 family and is already baked into the vectors — do not add it again.

Model

intfloat/multilingual-e5-base — 278M params, 768-dim, MIT licence, trained across 100+ languages, so Devanagari ↔ Latin and French surface forms are comparable.

• pooled output (sentence-transformers), max_seq_length 512
• encoded in fp16 (autocast) and stored as float16
• measured throughput: ~7,400 records/s on an RTX A6000

Note: the stored vectors are the model output. If you need strict cosine geometry, L2-normalize on load (v / np.linalg.norm(v, axis=1, keepdims=True)).

Row alignment — read this before using

Row i of each .npy corresponds to row i of the matching index parquet:

• emb_s1_full_*.npy ↔ index_s1.parquet
• emb_pool_full_*.npy ↔ index_pool.parquet

Both index files carry entity_id, country, name_raw, addr_raw, name_norm, addr_norm. There is no ground truth or target column here.

Measured performance

Candidate retrieval on the full 12.5M records (2.21M S1 × 10.32M pool), scored against the 7,638,365 ground-truth pairs in the training split:

blocker	true pairs recovered
_name_addr alone (top-50/query)	94.99%
_name alone (top-50/query)	64.30%
union of _name_addr + _name	98.25%
union of all three channels + exact-key string blocking	~99%

Practical notes from measuring this at full scale:

• top-100 per query is the recommended operating point. Moving to top-200 roughly doubles the pair count for about +0.0007 of eventual metric.
• Ranked top-K retrieval degrades gracefully with scale (95.8% on a 150k sample → 95.0% at full scale, i.e. −0.8pt). Frequency-capped string blocking does not — the same blockers lose 20–38 points. Prefer embeddings and exact keys over df-capped bucketing when you scale up.
• max(cosine) across channels is not comparable — z-score per channel before combining, or the union will be dominated by whichever channel has the widest spread.

Quick start

import numpy as np, pandas as pd

s1  = np.load("emb_s1_full_name_addr.npy",  mmap_mode="r")   # (2206821, 768) fp16
idx = pd.read_parquet("index_s1.parquet")                    # row-aligned ids

# L2-normalize so the dot product is cosine similarity
v = s1[0].astype(np.float32)
v /= np.linalg.norm(v)
print(idx.iloc[0]["entity_id"], v.shape)   # S1-925783039 (768,)

A country split is worth honouring on both sides: 100% of the ground-truth pairs in this task are same-country, so you only ever need to score S1 against the pool rows with the same country (2–3× fewer pairs, and no recall loss).

Licensing and attribution

• Model: intfloat/multilingual-e5-base — MIT.
• Data: derived from the Amazon ML Challenge 2026 dataset. The index_*.parquet files carry the source text fields, and the embeddings are computed over them. Redistribution is subject to the competition's own terms — check them before using this for anything beyond the competition. If you need a vectors-and-ids-only variant without the source text columns, open a discussion.

Citation

If this saves you GPU time, a link back to this dataset is appreciated.

@misc{amc26_er_embeddings,
  title  = {AMC26 Business Entity Resolution Embeddings (multilingual-e5-base)},
  author = {rishavk77},
  year   = {2026},
  note   = {Derived from the Amazon ML Challenge 2026 dataset}
}