"""Embed a SINGLE-FIELD text view with e5-small, for the F4 and F5 rescue channels. WHY SINGLE-FIELD. From the false-negative audit: of the copies that are never retrieved, 78% are outside the fused top-100 of every retriever, worth 0.416 val points. The reason is structural, not a tuning problem - all three retrievers embed name AND address together, so a copy whose name was scrambled or whose address was deleted is far away in the joint space however good the encoder is. The losses line up exactly with that: by address: empty 0.172, Indian addresses with no parsable house number 0.138 by name: scrambled 0.127, partial 0.108, typo 0.073, native script 0.069 A channel that reads only the surviving field is the only thing that can reach them. --view name --side pool --only-empty-address F4: name-only over the ~265k address-less records. Their address is gone, so including it is not merely useless, it is noise that dominates a short name. --view addr F5: address-only over the whole pool, which reaches scrambled and partial names sitting at a correct address. The model is the same multilingual-e5-small already used for the main channel, with the same "query: " prefix, so the output is directly comparable and needs no new download. """ from __future__ import annotations import argparse import json import os import sys import time import numpy as np import pandas as pd sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from berx import paths as P # noqa: E402 MODEL = "intfloat/multilingual-e5-small" PREFIX = "query: " def build_texts(df: pd.DataFrame, view: str) -> list[str]: if view == "name": src = df["business_name"].astype(str) elif view == "addr": src = df["business_address"].astype(str) else: raise ValueError(view) # An empty field would embed to whatever the prefix alone embeds to, which is the same # point for every such row - a dense cluster of mutually "identical" records. The country # keeps them apart and costs nothing. cc = df["country"].astype(str) return [PREFIX + (s.strip() or "?") + " | " + c for s, c in zip(src, cc)] def main(): ap = argparse.ArgumentParser() ap.add_argument("--split", default="test") ap.add_argument("--view", required=True, choices=["name", "addr"]) ap.add_argument("--side", required=True, choices=["s1", "pool"]) ap.add_argument("--out-channel", required=True) ap.add_argument("--only-empty-address", action="store_true", help="pool side only: restrict to records with no address (F4)") ap.add_argument("--batch", type=int, default=1024) ap.add_argument("--max-len", type=int, default=64) ap.add_argument("--device", default="cuda") a = ap.parse_args() import torch from transformers import AutoModel, AutoTokenizer d = os.path.dirname(P.work("prep", a.split, "_")) src = "source1.parquet" if a.side == "s1" else "pool.parquet" df = pd.read_parquet(os.path.join(d, src)) keep = np.arange(len(df)) if a.only_empty_address: assert a.side == "pool", "--only-empty-address applies to the pool side" keep = np.flatnonzero((df["business_address"].astype(str).str.strip() == "").to_numpy()) df = df.iloc[keep].reset_index(drop=True) print(f" restricted to {len(df):,} address-less records " f"({len(df)/len(keep) if len(keep) else 0:.0%} of the filter set)") texts = build_texts(df, a.view) print(f"{a.out_channel}/{a.split}_{a.side}: {len(texts):,} texts, view={a.view}") print(f" e.g. {texts[0][:90]!r}") tok = AutoTokenizer.from_pretrained(MODEL) model = AutoModel.from_pretrained(MODEL, dtype=torch.float16).eval().to(a.device) # Length-sort so a batch pads to its own longest member. On single-field text most rows # are very short and the corpus maximum is not representative of anything. order = np.argsort([len(t) for t in texts], kind="stable") out = np.empty((len(texts), 384), dtype=np.float16) # Checkpointing. This is a ~30 minute pass on a card shared with 25 other users, so it # will occasionally be killed. The counter is a position in the LENGTH-SORTED order, # which is the only order in which completed work forms a contiguous prefix. dest_early = os.path.join(P.EMB, a.out_channel, f"{a.split}_{a.side}") os.makedirs(dest_early, exist_ok=True) ck = os.path.join(dest_early, "partial") start = 0 if os.path.exists(ck + ".json"): meta_ck = json.load(open(ck + ".json")) if meta_ck.get("n") == len(texts) and meta_ck.get("view") == a.view: start = int(meta_ck["done"]) out = np.load(ck + ".npy") print(f" resuming at {start:,}/{len(texts):,}") else: print(" checkpoint is for a different input; ignoring") t0 = time.time() with torch.inference_mode(): for s in range(start, len(order), a.batch): idx = order[s:s + a.batch] enc = tok([texts[i] for i in idx], padding=True, truncation=True, max_length=a.max_len, return_tensors="pt").to(a.device) h = model(**enc).last_hidden_state m = enc["attention_mask"].unsqueeze(-1).to(h.dtype) v = (h * m).sum(1) / m.sum(1).clamp(min=1e-6) # mean pool, as e5 expects v = torch.nn.functional.normalize(v.float(), dim=1) out[idx] = v.half().cpu().numpy() if (s // a.batch) % 200 == 0 and s > start: np.save(ck + ".npy", out) json.dump({"done": int(s), "n": len(texts), "view": a.view}, open(ck + ".json", "w")) if (s // a.batch) % 200 == 0: done = (s + len(idx)) / len(order) el = time.time() - t0 print(f" {s+len(idx):>10,}/{len(order):,} ({done:6.1%}) " f"{(s+len(idx))/max(el,1e-9):,.0f} rows/s " f"eta {el/max(done,1e-9)-el:6.0f}s", flush=True) dest = P.emb_dir(a.out_channel, a.split, a.side) \ if a.out_channel in P.CHANNELS else \ os.path.join(P.EMB, a.out_channel, f"{a.split}_{a.side}") os.makedirs(dest, exist_ok=True) np.save(os.path.join(dest, "matrix.npy"), out) for ext in (".npy", ".json"): # the run finished; drop the partial if os.path.exists(ck + ext): os.remove(ck + ext) with open(os.path.join(dest, "ids.txt"), "w") as fh: fh.write("\n".join(df["entity_id"].astype(str)) + "\n") # The row->original-index map. F4's pool matrix covers only address-less records, so its # row i is NOT pool row i; anything consuming it must remap or every candidate index is # wrong. Saving it here is what makes that remap possible at all. np.save(os.path.join(dest, "rows.npy"), keep.astype(np.int64)) json.dump({"model": MODEL, "prefix": PREFIX, "view": a.view, "side": a.side, "n": len(df), "dim": 384, "subset": bool(a.only_empty_address), "seconds": round(time.time() - t0, 1)}, open(os.path.join(dest, "meta.json"), "w"), indent=1) print(f" wrote {dest} {out.shape} {time.time()-t0:.0f}s") if __name__ == "__main__": main()