code snapshot for train job

code/hf_jobs/train_stage.sh

@@ -0,0 +1,63 @@
+#!/usr/bin/env bash
+# HF Jobs (flavor cpu-xl): 200k train blocking study -> full train blocking -> fusion model training.
+# Inputs from the Hub: Arushhh/amlc-work (code/, norm/ parquet), Anupam-Rawat-IITB/data_ (raw TSVs).
+# Every stage uploads its outputs to Arushhh/amlc-work/<STAGE>/ immediately (job disk is ephemeral).
+set -uo pipefail
+ROOT=/workspace/amlc; mkdir -p $ROOT/blocking $ROOT/models $ROOT/parquet; cd $ROOT
+W=${WORKERS:-60}; STUDY_N=${STUDY_N:-200000}; TRAIN_N=${TRAIN_N:-300000}; RUN_FULL=${RUN_FULL:-1}
+log(){ echo "[$(date -u +%H:%M:%S)] $*"; }
+up(){ python -c "
+import sys,os
+from huggingface_hub import HfApi
+a=HfApi(); p=sys.argv[1]; d=sys.argv[2]
+if os.path.isdir(p): a.upload_folder(folder_path=p, path_in_repo=d, repo_id='Arushhh/amlc-work', repo_type='dataset', commit_message='job '+d)
+else: a.upload_file(path_or_fileobj=p, path_in_repo=d+'/'+os.path.basename(p), repo_id='Arushhh/amlc-work', repo_type='dataset', commit_message='job '+d)
+print('uploaded', p, '->', d)" "$1" "$2"; }
+log "deps"; pip install -q duckdb polars pyarrow scikit-learn scipy rapidfuzz lightgbm sparse-dot-topn huggingface_hub 2>&1 | tail -1
+nproc; free -g | head -2
+log "download code + norm parquet"
+hf download Arushhh/amlc-work --repo-type dataset --local-dir $ROOT/hub --include "code/*" "norm/*" 2>&1 | tail -1
+hf download Anupam-Rawat-IITB/data_ --repo-type dataset --local-dir $ROOT/raw --include "dataset/train/train_ground_truth.tsv" 2>&1 | tail -1
+ls $ROOT/hub/norm; ls $ROOT/hub/code/src
+python - <<'PY'
+import duckdb
+con=duckdb.connect(); con.execute("SET threads=32")
+con.execute("CREATE TABLE gt AS SELECT source1_entity_id, coalesce(matched_entity_ids,'') matched_entity_ids FROM read_csv('/workspace/amlc/raw/dataset/train/train_ground_truth.tsv', delim='\t', header=true, quote='', escape='', all_varchar=true)")
+con.execute("COPY gt TO '/workspace/amlc/parquet/gt.parquet' (FORMAT PARQUET)")
+con.execute("COPY (SELECT source1_entity_id AS a, unnest(string_split(matched_entity_ids,',')) AS b FROM gt WHERE matched_entity_ids<>'') TO '/workspace/amlc/parquet/pairs.parquet' (FORMAT PARQUET)")
+print("gt/pairs parquet written")
+PY
+cd $ROOT/hub/code
+log "STAGE 1: 200k train recall study (full pool)"
+python -m src.blocking --norm-dir $ROOT/hub/norm --split train --gt $ROOT/raw/dataset/train/train_ground_truth.tsv \
+  --out $ROOT/blocking/train_200k.parquet --max-s1 $STUDY_N --seed 13 --backend sdt --workers $W --reverse-scope full > $ROOT/blocking/train_200k.log 2>&1
+tail -60 $ROOT/blocking/train_200k.log; ls -la $ROOT/blocking
+up $ROOT/blocking/train_200k.log blocking; for f in $ROOT/blocking/train_200k*.json; do up "$f" blocking; done
+log "STAGE 2: fusion model on the 200k study candidates (first model; vendor-side competition features dropped)"
+python -m src.train_matcher --cands $ROOT/blocking/train_200k.parquet --norm-dir $ROOT/hub/norm \
+  --pairs $ROOT/parquet/pairs.parquet --gt $ROOT/parquet/gt.parquet --folds-file $ROOT/models/folds.parquet --folds 5 \
+  --workers $W --drop-features c_p_n,c_p_rank,c_p_gap,c_p_margin,c_p_n_rel --out-dir $ROOT/models/lgb_s200k > $ROOT/models/lgb_s200k.log 2>&1
+tail -80 $ROOT/models/lgb_s200k.log
+up $ROOT/models/lgb_s200k models/lgb_s200k; up $ROOT/models/lgb_s200k.log models; up $ROOT/models/folds.parquet models
+if [ "$RUN_FULL" = "1" ]; then
+  log "STAGE 3: full train blocking (all 2.2M S1) for vendor-side competition features"
+  python -m src.blocking --norm-dir $ROOT/hub/norm --split train --gt $ROOT/raw/dataset/train/train_ground_truth.tsv \
+    --out $ROOT/blocking/train_full.parquet --backend sdt --workers $W --reverse-cap 20 > $ROOT/blocking/train_full.log 2>&1
+  tail -60 $ROOT/blocking/train_full.log
+  up $ROOT/blocking/train_full.log blocking; for f in $ROOT/blocking/train_full*.json; do up "$f" blocking; done
+  log "STAGE 4: fusion model on full-train candidates (subsample $TRAIN_N S1 for features; competition features valid)"
+  python -m src.train_matcher --cands $ROOT/blocking/train_full.parquet --norm-dir $ROOT/hub/norm \
+    --pairs $ROOT/parquet/pairs.parquet --gt $ROOT/parquet/gt.parquet --folds-file $ROOT/models/folds.parquet --folds 5 \
+    --max-s1 $TRAIN_N --workers $W --out-dir $ROOT/models/lgb_full > $ROOT/models/lgb_full.log 2>&1
+  tail -80 $ROOT/models/lgb_full.log
+  up $ROOT/models/lgb_full models/lgb_full; up $ROOT/models/lgb_full.log models
+  log "STAGE 5: leave-one-country-out (France proxy)"
+  for C in India US; do
+    python -m src.train_matcher --cands $ROOT/blocking/train_full.parquet --norm-dir $ROOT/hub/norm \
+      --pairs $ROOT/parquet/pairs.parquet --gt $ROOT/parquet/gt.parquet --folds-file $ROOT/models/folds.parquet --folds 5 \
+      --max-s1 $TRAIN_N --workers $W --holdout-country $C --out-dir $ROOT/models/loco_$C > $ROOT/models/loco_$C.log 2>&1
+    tail -40 $ROOT/models/loco_$C.log; up $ROOT/models/loco_$C models/loco_$C; up $ROOT/models/loco_$C.log models
+  done
+  log "upload full train candidates (large)"; up $ROOT/blocking/train_full.parquet blocking
+fi
+log "ALL DONE"

code/scripts/hub_upload.py

@@ -0,0 +1,11 @@
+"""Upload a local folder to the private HF work repo. Token is read from STDIN (never from disk or argv).
+Usage:  echo "$HF_TOKEN" | python scripts/hub_upload.py /data/amlc/norm norm
+"""
+import sys, os, time
+from huggingface_hub import HfApi
+local, dest = sys.argv[1], sys.argv[2]
+token = sys.stdin.readline().strip()
+api = HfApi(token=token); t = time.time()
+api.upload_folder(folder_path=local, path_in_repo=dest, repo_id='Arushhh/amlc-work', repo_type='dataset',
+                  commit_message=f'upload {dest}', allow_patterns=['*.parquet', '*.json', '*.log', '*.txt'])
+print(f"uploaded {local} -> Arushhh/amlc-work/{dest} in {time.time()-t:.0f}s", flush=True)

code/scripts/preprocess_normalize.py

@@ -53,6 +53,32 @@ def work(args):
         r.pop('addr_postal',None)
         rows.append(r)
     return rows, errs
+
+SCHEMA=pa.schema([
+    ('entity_id',pa.string()),('country',pa.string()),('raw_name',pa.string()),('raw_address',pa.string()),
+    ('name_core',pa.string()),('name_legal',pa.string()),('name_tokens',pa.list_(pa.string())),('name_spaceless',pa.string()),
+    ('name_alt_names',pa.list_(pa.string())),('name_is_domain_form',pa.bool_()),('name_has_indic_script',pa.bool_()),('name_full',pa.string()),
+    ('name_translit',pa.string()),('name_translit_tokens',pa.list_(pa.string())),('name_translit_unknown',pa.int32()),
+    ('addr_tokens',pa.list_(pa.string())),('addr_tokens_translit',pa.list_(pa.string())),('addr_numbers',pa.list_(pa.string())),
+    ('addr_street_number',pa.string()),('addr_city',pa.string()),('addr_state',pa.string()),('addr_parts',pa.list_(pa.string())),
+    ('addr_district',pa.string()),('addr_localities',pa.list_(pa.string())),('addr_street',pa.string()),('blocking_keys',pa.list_(pa.string())),
+])
+def _to_table(rows):
+    cols={f.name:[r.get(f.name) for r in rows] for f in SCHEMA}
+    arrays=[]
+    for f in SCHEMA:
+        v=cols[f.name]
+        if pa.types.is_list(f.type): v=[[str(x) for x in (vv or [])] for vv in v]
+        elif pa.types.is_string(f.type): v=['' if vv is None else str(vv) for vv in v]
+        elif pa.types.is_boolean(f.type): v=[bool(vv) for vv in v]
+        else: v=[int(vv or 0) for vv in v]
+        # Build the array with an explicit type so an all-empty list column (e.g. name_alt_names with
+        # no rows matched in this chunk) is still typed list<string>, not the list<null> pyarrow infers
+        # from an untyped Python list of empty lists — that mismatch broke ParquetWriter.write_table
+        # across chunks with a fixed schema.
+        arrays.append(pa.array(v, type=f.type))
+    return pa.Table.from_arrays(arrays, schema=SCHEMA)
+
 def run_table(tbl):
     t0=time.time(); src=f'{R}/parquet/{tbl}.parquet'; os.makedirs(f'{R}/norm',exist_ok=True); out=f'{R}/norm/{tbl}.parquet'
     T=pq.read_table(src, columns=['entity_id','business_name','business_address','country'])
@@ -63,8 +89,8 @@ def run_table(tbl):
     with Pool(W) as pool:
         for rows,e in pool.imap(work, chunks, chunksize=1):
             errs+=e; done+=len(rows)
-            tab=pa.Table.from_pylist(rows)
-            if writer is None: writer=pq.ParquetWriter(out, tab.schema, compression='zstd')
+            tab=_to_table(rows)
+            if writer is None: writer=pq.ParquetWriter(out, SCHEMA, compression='zstd')
             writer.write_table(tab)
             if done % (CH*25) == 0: print(f"  {tbl}: {done}/{n} {time.time()-t0:.0f}s", flush=True)
     writer.close()