| """Step 0. Raw TSV -> parquet, plus the small side-tables every later stage needs. |
| |
| Run once per split, on the college box. Cheap (a few minutes) and it removes the largest |
| recurring cost in the whole pipeline: re-parsing 10.3M TSV rows in every process that needs |
| a business name. |
| |
| WHAT IT WRITES, all under BERX_WORK/prep/<split>/ |
| source{1,2,3}.parquet raw columns, row order preserved exactly |
| pool.parquet S2 rows then S3 rows, concatenated - this concatenation order is |
| the contract every embedding matrix and every candidate index in |
| this codebase assumes |
| country_s1.npy per-row country code, for the country-blocked retrieval |
| country_pool.npy |
| ids.json id <-> row maps, so a stage can check an index instead of trusting it |
| |
| The row-order assertion is not defensive padding. Embeddings were produced in source order and |
| are addressed positionally; a single reordered row shifts every candidate index after it and |
| produces a submission that is wrong in a way no validator catches. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import os |
| import sys |
|
|
| 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 |
|
|
| COLS = ["entity_id", "business_name", "business_address", "country"] |
|
|
|
|
| def read_source(split: str, i: int) -> pd.DataFrame: |
| p = P.raw(split, i) |
| if p.endswith(".parquet"): |
| return pd.read_parquet(p) |
| return pd.read_csv(p, sep="\t", dtype=str, keep_default_na=False, na_filter=False) |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--split", default="test", choices=["train", "test"]) |
| a = ap.parse_args() |
| out = P.work("prep", a.split, "_") |
| out = os.path.dirname(out) |
| os.makedirs(out, exist_ok=True) |
|
|
| frames = {} |
| for i in (1, 2, 3): |
| df = read_source(a.split, i) |
| missing = [c for c in COLS if c not in df.columns] |
| assert not missing, f"source{i} is missing {missing}; got {list(df.columns)}" |
| df = df[COLS] |
| assert df["entity_id"].is_unique, f"source{i} has duplicate entity_id" |
| df.to_parquet(os.path.join(out, f"source{i}.parquet"), index=False) |
| frames[i] = df |
| print(f" source{i}: {len(df):>10,} rows " |
| f"{df['country'].value_counts().to_dict()}") |
|
|
| pool = pd.concat([frames[2], frames[3]], ignore_index=True) |
| pool.to_parquet(os.path.join(out, "pool.parquet"), index=False) |
| print(f" pool : {len(pool):>10,} rows (S2 {len(frames[2]):,} then S3 {len(frames[3]):,})") |
|
|
| |
| cats = sorted(set(frames[1]["country"]) | set(pool["country"])) |
| cmap = {c: i for i, c in enumerate(cats)} |
| np.save(os.path.join(out, "country_s1.npy"), |
| frames[1]["country"].map(cmap).to_numpy(np.int8)) |
| np.save(os.path.join(out, "country_pool.npy"), |
| pool["country"].map(cmap).to_numpy(np.int8)) |
|
|
| with open(os.path.join(out, "ids.json"), "w") as fh: |
| json.dump({"country_map": cmap, "n_s1": len(frames[1]), |
| "n_s2": len(frames[2]), "n_s3": len(frames[3]), |
| "n_pool": len(pool)}, fh, indent=1) |
|
|
| empt = (pool["business_address"].str.strip() == "").mean() |
| print(f" empty-address rate in pool: {empt:.3%}") |
| print(f" wrote {out}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
