code/scripts/eda_pairs_full.py

"""Full-scale noise audit over all labelled pairs. Runs on the AWS box against /opt/dlami/nvme/amlc/amlc.duckdb."""
import duckdb, time, os, sys
import pandas as pd
pd.set_option("display.width", 250); pd.set_option("display.max_columns", 60); pd.set_option("display.max_rows", 200)
R=os.environ.get('ROOT','/opt/dlami/nvme/amlc'); t0=time.time()
con=duckdb.connect(f'{R}/amlc.duckdb'); con.execute(f"SET threads=8; SET memory_limit='20GB'; SET temp_directory='{R}/duck_tmp'; SET preserve_insertion_order=false;")
q=lambda s: con.execute(s).df(); P=lambda *a: print(*a, f"[{time.time()-t0:.0f}s]", flush=True)
LEGAL=r"\b(inc|incorporated|corp|corporation|co|company|llc|l l c|ltd|limited|llp|pllc|pc|plc|lp|pvt|private|opc|sarl|s a r l|sas|s a s|sasu|eurl|sa|s a|sci|snc|ei|ets|etablissements)\b"
def NN(c): return f"trim(regexp_replace(regexp_replace(lower(strip_accents({c})),'[^a-z0-9]+',' ','g'),'\\s+',' ','g'))"
def CORE(c): return f"trim(regexp_replace(regexp_replace({NN(c)},'{LEGAL}',' ','g'),'\\s+',' ','g'))"
INDIC=r"[\p{Devanagari}\p{Bengali}\p{Gurmukhi}\p{Gujarati}\p{Tamil}\p{Telugu}\p{Kannada}\p{Malayalam}]"
con.execute("CREATE OR REPLACE VIEW s23 AS SELECT *, 'S2' AS src FROM s2 UNION ALL SELECT *, 'S3' AS src FROM s3")
P("building pair feature table over ALL gt pairs")
con.execute(f"""CREATE OR REPLACE TABLE pf AS
SELECT p.a, p.b, y.src, x.country,
  x.business_name n1, y.business_name n2, x.business_address a1, y.business_address a2,
  {NN('x.business_name')} nn1, {NN('y.business_name')} nn2, {CORE('x.business_name')} c1, {CORE('y.business_name')} c2,
  {NN('x.business_address')} na1, {NN('y.business_address')} na2,
  regexp_matches(y.business_name,'{INDIC}') indic_name, regexp_matches(y.business_address,'{INDIC}') indic_addr,
  regexp_matches(lower(y.business_name),'(\\.(com|in|fr|org|net|c0m)\\b|^#[a-z])') domain_form,
  regexp_matches(y.business_name,'[À-ɏ]') AND NOT regexp_matches(x.business_name,'[À-ɏ]') accent_injected,
  regexp_matches(lower(y.business_name),'(f/k/a|formerly|fka|dba|d/b/a|trading as|t/a)') former_form,
  regexp_matches(y.business_name,'(--|<<|>>|\\||\\[|\\]|\\(|\\))') junk_name,
  regexp_matches(y.business_name,'\\d') AND NOT regexp_matches(x.business_name,'\\d') digit_injected,
  regexp_matches(y.business_name,'^\\s*(M/s|M/S|Dr\\.?|Mr\\.?|Shri|Sri)\\s') prefix_added,
  trim(y.business_address)='' addr_empty, regexp_matches(y.business_address,'(?i)\\bnull\\b') addr_null,
  regexp_matches(lower(y.business_address),'\\bpo box\\b') po_box, regexp_matches(y.business_address,'\\b\\d+ 1/2\\b') half_num,
  regexp_extract(x.business_address,'(\\d+)',1) num1, regexp_extract(y.business_address,'(\\d+)',1) num2,
  regexp_matches(x.business_address,'^\\s*\\d') s1_starts_num, regexp_matches(y.business_address,'^\\s*\\d') v_starts_num,
  y.business_name=upper(y.business_name) AND regexp_matches(y.business_name,'[A-Z]') caps_name,
  levenshtein({CORE('x.business_name')}, {CORE('y.business_name')}) lev_core,
  jaro_winkler_similarity({CORE('x.business_name')}, {CORE('y.business_name')}) jw_core
FROM pairs p JOIN s1 x ON x.entity_id=p.a JOIN s23 y ON y.entity_id=p.b""")
P("rows", con.execute("SELECT count(*) FROM pf").fetchone()[0])
con.execute("""CREATE OR REPLACE TABLE pf2 AS SELECT *,
  list_sort(list_distinct(string_split(c1,' '))) t1, list_sort(list_distinct(string_split(c2,' '))) t2,
  list_sort(list_distinct(string_split(na1,' '))) at1, list_sort(list_distinct(string_split(na2,' '))) at2
  FROM pf""")
con.execute("""CREATE OR REPLACE TABLE pf3 AS SELECT *,
  len(list_intersect(t1,t2))*1.0/greatest(1,len(list_distinct(list_concat(t1,t2)))) name_j,
  len(list_intersect(at1,at2))*1.0/greatest(1,len(list_distinct(list_concat(at1,at2)))) addr_j,
  len(t1) nt1, len(t2) nt2, len(list_intersect(t1,t2)) nti,
  len(at1) nat1, len(at2) nat2, len(list_intersect(at1,at2)) nati
  FROM pf2""")
P("feature tables done")

print("\n=== NAME NOISE OPERATION MIX (share of all true pairs; categories assigned in priority order) ===")
cat = """CASE
  WHEN indic_name THEN '01_indic_script'
  WHEN domain_form THEN '02_domain_form'
  WHEN former_form THEN '03_former_name_form'
  WHEN nn1=nn2 THEN '04_identical_after_norm'
  WHEN c1=c2 THEN '05_legal_suffix_only'
  WHEN t1=t2 THEN '06_reorder_or_dup_only'
  WHEN nti=nt1 AND nt2>nt1 THEN '07_words_added'
  WHEN nti=nt2 AND nt1>nt2 THEN '08_words_dropped'
  WHEN name_j=0 THEN '09_complete_rename'
  WHEN lev_core<=2 THEN '10_typo_lev<=2'
  WHEN lev_core<=5 THEN '11_typo_lev3-5'
  WHEN name_j>=0.5 THEN '12_partial_overlap_j>=0.5'
  ELSE '13_low_overlap' END"""
print(q(f"SELECT {cat} op, count(*) n, round(count(*)*100.0/(SELECT count(*) FROM pf3),2) pct, round(avg(name_j),3) name_j, round(avg(addr_j),3) addr_j, round(avg(CASE WHEN addr_empty THEN 1 ELSE 0 END),3) addr_empty FROM pf3 GROUP BY 1 ORDER BY 1").to_string(index=False))
print("\nby source and country (pct of that group):")
print(q(f"SELECT {cat} op, src, country, round(count(*)*100.0/sum(count(*)) OVER (PARTITION BY src,country),2) pct FROM pf3 GROUP BY 1,2,3 ORDER BY 1,2,3").pivot(index='op',columns=['src','country'],values='pct').round(2).to_string())
print("\nsecondary flags (share of all pairs):")
print(q("SELECT round(avg(accent_injected::int),4) accent_injected, round(avg(junk_name::int),4) junk_name, round(avg(digit_injected::int),4) digit_injected, round(avg(prefix_added::int),4) prefix_added, round(avg(caps_name::int),4) caps_name, round(avg((jw_core<0.8)::int),4) jw_core_lt_0_8, round(avg((jw_core<0.9)::int),4) jw_core_lt_0_9 FROM pf3").to_string(index=False))
P("name mix done")

print("\n=== ADDRESS NOISE MIX (priority order) ===")
acat = """CASE
  WHEN addr_empty THEN '01_empty'
  WHEN na1=na2 THEN '02_identical_after_norm'
  WHEN at1=at2 THEN '03_reorder_only'
  WHEN nati=nat2 AND nat1>nat2 THEN '04_components_dropped'
  WHEN nati=nat1 AND nat2>nat1 THEN '05_components_added'
  WHEN addr_j=0 THEN '06_no_overlap'
  WHEN addr_j>=0.6 THEN '07_partial_j>=0.6'
  WHEN addr_j>=0.3 THEN '08_partial_j0.3-0.6'
  ELSE '09_low_overlap' END"""
print(q(f"SELECT {acat} op, count(*) n, round(count(*)*100.0/(SELECT count(*) FROM pf3),2) pct, round(avg(name_j),3) name_j FROM pf3 GROUP BY 1 ORDER BY 1").to_string(index=False))
print(q(f"SELECT {acat} op, src, country, round(count(*)*100.0/sum(count(*)) OVER (PARTITION BY src,country),2) pct FROM pf3 GROUP BY 1,2,3 ORDER BY 1,2,3").pivot(index='op',columns=['src','country'],values='pct').round(2).to_string())
print("\nstreet number agreement (S1 address starts with a number):")
print(q("""SELECT src, country, count(*) n,
  round(avg(CASE WHEN num2='' THEN 1 ELSE 0 END),3) vendor_no_number,
  round(avg(CASE WHEN num2<>'' AND ltrim(num1,'0')=ltrim(num2,'0') THEN 1 ELSE 0 END),3) num_equal,
  round(avg(CASE WHEN num2<>'' AND ltrim(num1,'0')<>ltrim(num2,'0') THEN 1 ELSE 0 END),3) num_differs,
  round(avg(CASE WHEN num2<>'' AND ltrim(num1,'0')<>ltrim(num2,'0') AND regexp_matches(y_addr_hack,'x') THEN 1 ELSE 0 END),3) placeholder
  FROM (SELECT *, '' y_addr_hack FROM pf3) WHERE s1_starts_num AND NOT addr_empty GROUP BY 1,2 ORDER BY 1,2""").drop(columns=['placeholder']).to_string(index=False))
print("when num differs, is S1's number still present anywhere in vendor address?")
print(q("""SELECT src, country, round(avg(CASE WHEN regexp_matches(na2, '\\b'||ltrim(num1,'0')||'\\b') THEN 1 ELSE 0 END),3) s1num_present_elsewhere, count(*) n
  FROM pf3 WHERE s1_starts_num AND NOT addr_empty AND num2<>'' AND ltrim(num1,'0')<>ltrim(num2,'0') AND num1<>'' GROUP BY 1,2 ORDER BY 1,2""").to_string(index=False))
print("\nsecondary address flags:")
print(q("SELECT src, country, round(avg(addr_null::int),4) null_tok, round(avg(po_box::int),4) po_box, round(avg(half_num::int),4) half_num, round(avg(indic_addr::int),4) indic_addr, round(avg(v_starts_num::int),3) v_starts_num FROM pf3 GROUP BY 1,2 ORDER BY 1,2").to_string(index=False))
P("address mix done")

print("\n=== JOINT: how many true pairs are hard on BOTH fields ===")
print(q("SELECT round(avg(CASE WHEN name_j=0 THEN 1 ELSE 0 END),4) name_j0, round(avg(CASE WHEN addr_j=0 OR addr_empty THEN 1 ELSE 0 END),4) addr_j0_or_empty, round(avg(CASE WHEN name_j=0 AND (addr_j=0 OR addr_empty) THEN 1 ELSE 0 END),5) both, round(avg(CASE WHEN name_j<0.34 AND addr_j<0.34 THEN 1 ELSE 0 END),4) both_lt_034, round(avg(CASE WHEN jw_core<0.85 AND addr_j<0.5 THEN 1 ELSE 0 END),4) jw85_addr50 FROM pf3").to_string(index=False))
print("name_j x addr_j joint distribution (pct):")
print(q("SELECT CASE WHEN name_j=0 THEN 'n=0' WHEN name_j<0.34 THEN 'n<.34' WHEN name_j<0.67 THEN 'n<.67' WHEN name_j<1 THEN 'n<1' ELSE 'n=1' END nb, CASE WHEN addr_empty THEN 'a=empty' WHEN addr_j=0 THEN 'a=0' WHEN addr_j<0.34 THEN 'a<.34' WHEN addr_j<0.67 THEN 'a<.67' WHEN addr_j<1 THEN 'a<1' ELSE 'a=1' END ab, round(count(*)*100.0/(SELECT count(*) FROM pf3),2) pct FROM pf3 GROUP BY 1,2").pivot(index='nb',columns='ab',values='pct').fillna(0).to_string())
P("joint done")

print("\n=== WITHIN-ENTITY VENDOR DUPLICATES (collective signal): similarity between two vendor records of the SAME S1 entity ===")
print(q("""SELECT x.src||'-'||y.src kind, count(*) n, round(avg(CASE WHEN x.c2=y.c2 THEN 1 ELSE 0 END),3) core_equal,
  round(avg(len(list_intersect(x.t2,y.t2))*1.0/greatest(1,len(list_distinct(list_concat(x.t2,y.t2))))),3) name_j,
  round(avg(len(list_intersect(x.at2,y.at2))*1.0/greatest(1,len(list_distinct(list_concat(x.at2,y.at2))))),3) addr_j,
  round(avg(CASE WHEN len(list_intersect(x.t2,y.t2))=0 THEN 1 ELSE 0 END),3) name_j0
  FROM (SELECT * FROM pf3 USING SAMPLE 1500000 ROWS (reservoir, 5)) x JOIN pf3 y ON x.a=y.a AND x.b<y.b GROUP BY 1 ORDER BY 1""").to_string(index=False))
P("collective done")

print("\n=== TRANSLITERATION LEXICON FEASIBILITY (Indic-script vendor names) ===")
print(q("""SELECT src, country, count(*) n, round(avg(CASE WHEN len(string_split(trim(n2),' '))=len(string_split(nn1,' ')) THEN 1 ELSE 0 END),3) same_token_count,
  round(avg(len(string_split(trim(n2),' '))),2) v_tokens, round(avg(len(string_split(nn1,' '))),2) s1_tokens, round(avg(addr_j),3) addr_j, round(avg(CASE WHEN addr_empty THEN 1 ELSE 0 END),3) addr_empty
  FROM pf3 WHERE indic_name GROUP BY 1,2 ORDER BY 1,2""").to_string(index=False))
print("top 30 Indic tokens with their most common aligned Latin token (position-aligned, same token count):")
print(q("""WITH al AS (SELECT unnest(string_split(trim(n2),' ')) itok, unnest(string_split(nn1,' ')) ltok FROM pf3 WHERE indic_name AND len(string_split(trim(n2),' '))=len(string_split(nn1,' ')))
  , c AS (SELECT itok, ltok, count(*) n FROM al GROUP BY 1,2), tot AS (SELECT itok, sum(n) tn FROM c GROUP BY 1)
  SELECT c.itok, c.ltok, c.n, round(c.n*1.0/tot.tn,3) purity FROM c JOIN tot USING(itok) QUALIFY row_number() OVER (PARTITION BY c.itok ORDER BY c.n DESC)=1 ORDER BY tot.tn DESC LIMIT 30""").to_string(index=False))
print("distinct Indic-script vendor name tokens:", con.execute("SELECT count(distinct itok) FROM (SELECT unnest(string_split(trim(n2),' ')) itok FROM pf3 WHERE indic_name)").fetchone()[0])
P("translit done")

print("\n=== COMPLETE RENAMES: what do they look like ===")
print(q("SELECT src, country, n1, n2, a1, a2 FROM pf3 WHERE name_j=0 AND NOT indic_name AND NOT domain_form AND NOT former_form USING SAMPLE 20 ROWS (reservoir, 3)").to_string(index=False))
print("rename share by src/country:", q("SELECT src, country, round(avg(CASE WHEN name_j=0 AND NOT indic_name AND NOT domain_form AND NOT former_form THEN 1 ELSE 0 END),4) rename_share FROM pf3 GROUP BY 1,2 ORDER BY 1,2").to_string(index=False))
print("\n=== S1 side: how often does the S1 entity's name collide with another S1 in same country, by whether pair is hard ===")
con.execute(f"CREATE OR REPLACE TABLE s1nn AS SELECT entity_id, country, {CORE('business_name')} c FROM s1")
con.execute("CREATE OR REPLACE TABLE s1cnt AS SELECT entity_id, count(*) OVER (PARTITION BY country, c) cnt FROM s1nn")
print(q("SELECT CASE WHEN cnt=1 THEN '1' WHEN cnt<5 THEN '2-4' WHEN cnt<20 THEN '5-19' ELSE '20+' END s1_name_freq, count(*) n_pairs, round(avg(name_j),3) name_j, round(avg(addr_j),3) addr_j FROM pf3 JOIN s1cnt ON s1cnt.entity_id=pf3.a GROUP BY 1 ORDER BY 1").to_string(index=False))
con.execute(f"COPY (SELECT a,b,src,country,name_j,addr_j,lev_core,jw_core,indic_name,domain_form,former_form,addr_empty FROM pf3) TO '{R}/parquet/pair_audit.parquet' (FORMAT PARQUET)")
P("ALL DONE")