Add FinGuard-Privacy-Benchmark v2 dataset, card, seeds audit and scripts

README.md

@@ -0,0 +1,108 @@
+---
+license: cc-by-4.0
+language:
+- en
+pretty_name: FinGuard-Privacy-Benchmark
+size_categories:
+- 1K<n<10K
+task_categories:
+- text-classification
+tags:
+- membership-inference
+- privacy
+- synthetic
+- banking
+- intent-classification
+configs:
+- config_name: default
+  default: true
+  data_files:
+  - split: train
+    path: data/train.parquet
+  - split: test
+    path: data/test.parquet
+- config_name: full
+  data_files:
+  - split: all
+    path: full/dataset_v2.parquet
+- config_name: seeds
+  data_files:
+  - split: all
+    path: seeds/seeds_audited.parquet
+---
+
+# FinGuard-Privacy-Benchmark
+
+A synthetic, privacy-flavoured **banking customer-support intent dataset** built to benchmark
+**membership inference attacks (MIA)** such as LiRA against fine-tuned text classifiers.
+It was created for CS684 Assignment 1 (Membership Inference Attacks).
+
+- **9,120 messages, 57 intents, exactly 160 per intent.**
+- **Clean labels.** Every row was independently re-labelled by a second LLM; only rows where it agreed with the intended intent are kept. No label noise was injected on purpose.
+- **Fake personal details in ~35% of rows** (names, cities, amounts, dates, reference numbers, card digits, merchants). Everything is generated with Faker / an RNG. No real personal data.
+- **Messy, realistic text**: typos, slang, fragments, run-ons, plus a mix of clean rows.
+- **Pre-defined 1/3 – 2/3 split** for the MIA protocol: the *train* split (3,023 rows) is what a target model is trained on; the *test* split (6,097 rows) is held out and is the pool from which shadow models draw their random halves.
+
+## Why this dataset exists
+
+MIA assignments need a text-classification set that (1) is privacy-relevant, (2) has clean labels, and (3) is **provably absent from the pretraining data** of the model being attacked. Banking77 is the natural candidate but has been public since 2020 and is likely inside the pretraining corpora of modern encoders such as ModernBERT (whose pretraining data is undisclosed). So instead of using Banking77 directly we use it only as *grounding*, and train/attack on **freshly generated text**.
+
+## How it was built
+
+1. **Seed pool.** Banking77 (PolyAI, CC BY 4.0), train + test pooled: 13,083 utterances.
+2. **Duplicate audit.** Strict normalisation (NFKC, casefold, alphanumerics only, so "top-up" = "top up") removes 68 rows in total, including three texts that appeared with conflicting labels (dropped entirely). An independent re-check against a second mirror (`mteb/banking77`) matched. Result: 13,015 unique seeds.
+3. **Label-noise audit of the seeds.** Three independent detectors (cleanlab confident learning on MiniLM embeddings; logistic regression on bge-small embeddings; kNN voting), plus a model-free check for near-identical texts with different labels. 209 seeds (1.6%) are flagged by at least 2 of 3 detectors. Most flagged rows are genuinely ambiguous intent pairs (e.g. `top_up_reverted` vs `top_up_failed`), not typos. See `seeds/seeds_audited.parquet`.
+4. **Clean pool and intent pruning.** Rows flagged by any detector or in a conflicting near-duplicate pair were dropped (13,015 → 12,360). Noise was concentrated in confusable intent families (transfers, top-ups, card delivery, identity verification, exchange rates), so 20 hub intents of the confusion graph were dropped, leaving 8,971 real rows over **57 intents** (`in_clean_pool=True` in the seeds file). These real rows are used only as few-shot examples for generation and as a held-out real-text check, and are **not** in the dataset.
+   Dropped intents: `balance_not_updated_after_bank_transfer`, `topping_up_by_card`, `card_payment_fee_charged`, `supported_cards_and_currencies`, `transfer_not_received_by_recipient`, `card_arrival`, `card_payment_wrong_exchange_rate`, `card_payment_not_recognised`, `verify_my_identity`, `reverted_card_payment?`, `beneficiary_not_allowed`, `balance_not_updated_after_cheque_or_cash_deposit`, `declined_cash_withdrawal`, `exchange_via_app`, `order_physical_card`, `compromised_card`, `top_up_by_bank_transfer_charge`, `top_up_failed`, `get_disposable_virtual_card`, `getting_spare_card`.
+5. **Generation.** `deepseek-flash` (DeepSeek-V4.1-Flash), reasoning off, few-shot with 6 real examples of the target intent, plus the names and one example of the 2 most confusable neighbouring intents as "do not write these". Two passes: a clean-style pass (~11k candidates) and a deliberately messy pass (~5k candidates). The model writes personal details only as placeholders (`{NAME}`, `{AMOUNT}`, `{CITY}`, `{DATE}`, `{REF}`, `{LAST4}`, `{MERCHANT}`).
+6. **Post-processing.** 25% of the clean-pass rows get light typo/slang/punctuation perturbation; PII placeholders are injected (safe patterns only: name greeting, reference number, city, date) until ~32% of rows have some; placeholders are filled with fresh Faker/RNG values.
+7. **Verification.** `deepseek-v4-pro` classifies every candidate among the 57 intents; a row survives only if it picks the intended one. Agreement on the 16,217 candidates: 99.0% (clean 99.5%, LLM-messy 99.6%, perturbed 96.5%). Calibration: the same verifier scores **93.2% on 400 held-out real Banking77 rows**, i.e. real text is much more ambiguous than the synthetic text.
+8. **Deduplication and balancing.** Exact and near-duplicate (bge-small cosine ≥ 0.96 within an intent) removal, removal of anything ≥ 0.97 similar to any real Banking77 row, removal of degenerate generations (> 100 words), then balancing to 160 rows per intent (up to 64 messy-LLM rows per intent first, so the mix is ~40% messy).
+9. **Split.** Stratified 1/3 train, 2/3 test per intent. Clusters of near-duplicates (cosine ≥ 0.95) are kept on the same side, so no near-duplicate pair crosses the split.
+
+All generation and verification code is in `scripts/` (API keys are read from the environment, none are stored here).
+
+## Data fields
+
+`default` config (`train`, `test`):
+
+| field | type | description |
+|---|---|---|
+| `text` | string | the customer message, with fake personal details filled in |
+| `text_template` | string | same message with `{PLACEHOLDER}` slots, as generated |
+| `intent` | string | intent name (57 classes) |
+| `label` | int | integer id of the intent (sorted alphabetically, ASCII order) |
+| `has_pii` | bool | message contains fake personal details |
+| `pii_types` | list[string] | any of `name, amount, location, date, reference, card_digits, merchant` |
+| `noise_type` | string | `clean`, `perturbed` (programmatic typos) or `llm_noisy` (messy LLM pass) |
+
+`full` config: the same rows in one file with an extra `split` column (`train` / `test`).
+`seeds` config: the 13,015 deduplicated real Banking77 rows with the detector flags (`suspect_cleanlab`, `suspect_lr_bge`, `suspect_knn_bge`, `votes`, `suspect_consensus`, `in_clean_pool`), included to document the grounding.
+
+## Statistics
+
+| | |
+|---|---|
+| rows | 9,120 (train 3,023 / test 6,097) |
+| intents | 57 × 160 rows |
+| `noise_type` | clean 4,043 · llm_noisy 3,637 · perturbed 1,440 |
+| rows with fake PII | 34.7% |
+| words per message | mean 16.3, median 14, p10 6, p90 31, max 80 |
+| bge-small + logistic regression, 5-fold CV accuracy | 97.8% (real Banking77 is about 93%) |
+
+## Intended use
+
+Benchmarking membership inference attacks (LOSS, LiRA offline/online, etc.) and their ablations (number of shadow models, over/under-fitting, signal choice) on fine-tuned text classifiers, and studying how memorisation depends on personal-detail content and text noise.
+
+## Limitations and caveats
+
+- **Easier than real data.** Confusable intents are cleanly separated in the generated text (verifier agreement 99% vs 93% on real text; simple classifier 97.8% CV accuracy). Expect strong classifiers to score very high, and expect weaker per-example signal for MIA than on natural data.
+- **Same-family bias.** The generator and the verifier are both DeepSeek models, so shared stylistic and semantic biases can pass verification.
+- **Synthetic messiness ≠ real messiness.** Typos and slang are LLM- or rule-generated; some injected personal details read slightly oddly (e.g. a city name in a sentence that does not need one).
+- **Clean labels by design.** Label-noise/mislabelled-record analyses can only use the real seed file, not this dataset.
+- **Not a privacy guarantee.** All personal details are fake, but generated text may resemble real messages. Do not treat the data as a source of real customer behaviour.
+- **Pretraining contamination.** The messages were generated in September 2026 and cannot appear in the pretraining data of models released before that (e.g. ModernBERT, BERT, RoBERTa). Once this dataset is public, models trained afterwards may see it; use models that predate the release when you need the non-contamination property.
+
+## Licence and attribution
+
+CC BY 4.0. The seed rows in `seeds/` and the few-shot grounding come from **Banking77** (Casanueva et al., 2020, *Efficient Intent Detection with Dual Sentence Encoders*), released under CC BY 4.0. Synthetic text was produced with DeepSeek models; check the provider's terms for downstream use of generated outputs.

data/test.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c3d4d7f430baf6346c9fe85220b9f79de23da0ced00b1ab78a2524f762798b91
+size 538322

data/train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8e41f9a07533a221aa4c9d017fc314ac41d16bbda635d0e58750b585010b0b77
+size 276923

full/dataset_v2.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5e67543f91b473472150ccf0f83ada820b0282ccbf8aaead85e6e0e0abc01568
+size 790168

scripts/build_dataset.py

@@ -0,0 +1,107 @@
+"""Verified synthetic rows -> deduped, balanced, PII-filled dataset with a stratified 1/3 train / 2/3 test split
+in which near-duplicate clusters never cross the split."""
+import argparse, re, random, unicodedata
+import numpy as np, pandas as pd
+from faker import Faker
+from sentence_transformers import SentenceTransformer
+
+TYPES = {"NAME": "name", "AMOUNT": "amount", "LAST4": "card_digits", "MERCHANT": "merchant", "CITY": "location", "DATE": "date", "REF": "reference"}
+MERCHANTS = ["Amazon", "Starbucks", "Tesco", "Uber", "Netflix", "Spotify", "Walmart", "Target", "IKEA", "Zara", "Airbnb", "Apple Store",
+             "Best Buy", "Lidl", "Deliveroo", "Ryanair", "Booking.com", "Nike", "eBay", "Shell"]
+
+def strict(s):
+    return re.sub(r"[\W_]+", "", unicodedata.normalize("NFKC", s).casefold())
+
+def fill(t, fk, rng):
+    """Fresh fake values per placeholder occurrence (Faker + RNG only; nothing real)."""
+    gen = {"NAME": lambda: fk.first_name() if rng.random() < 0.6 else fk.name(),
+           "AMOUNT": lambda: rng.choice(["£", "£", "£", "$", "€", ""]) + str(rng.choice([rng.randint(5, 99), rng.randint(100, 999), round(rng.uniform(5, 900), 2)])),
+           "LAST4": lambda: f"{rng.randint(0, 9999):04d}", "MERCHANT": lambda: rng.choice(MERCHANTS), "CITY": fk.city,
+           "DATE": lambda: rng.choice([fk.date_object().strftime("%d/%m"), fk.date_object().strftime("%-d %B"), f"the {rng.randint(1, 28)}th"]),
+           "REF": lambda: rng.choice([f"TXN-{rng.randint(100000, 999999)}", f"{rng.randint(10**7, 10**8 - 1)}", f"REF{rng.randint(1000, 9999)}X"])}
+    return re.sub(r"\{(\w+)\}", lambda m: str(gen[m.group(1)]()), t)
+
+def components(E, thr):
+    """Connected components of the cosine >= thr graph (union-find)."""
+    par = list(range(len(E)))
+    def f(x):
+        while par[x] != x: par[x] = par[par[x]]; x = par[x]
+        return x
+    S = E @ E.T
+    for i, j in zip(*np.where(np.triu(S >= thr, 1))): par[f(i)] = f(j)
+    return np.array([f(i) for i in range(len(E))])
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--inp", default="data/synth_verified.jsonl")
+    ap.add_argument("--out", default="data/dataset.parquet")
+    ap.add_argument("--per-intent", type=int, default=160)
+    ap.add_argument("--noisy-quota", type=int, default=0, help="per intent, take up to this many llm_noisy rows first")
+    ap.add_argument("--sim", type=float, default=0.96, help="within-synthetic near-duplicate cosine threshold (bge)")
+    ap.add_argument("--real-sim", type=float, default=0.97, help="drop synthetic rows this close to any real seed")
+    ap.add_argument("--split-sim", type=float, default=0.95, help="rows this similar are kept on the same side of the split")
+    ap.add_argument("--max-words", type=int, default=100, help="drop degenerate generations (e.g. several messages concatenated)")
+    ap.add_argument("--seed", type=int, default=0)
+    a = ap.parse_args()
+    rng, fk = random.Random(a.seed), Faker("en_US"); Faker.seed(a.seed)
+    slots = set(TYPES)
+
+    df = pd.read_json(a.inp, lines=True)
+    if "noise_type" not in df: df["noise_type"] = "clean"
+    n0 = len(df)
+    df = df[df.verified]; n_ver = len(df)
+    df = df[df.text.str.split().str.len() <= a.max_words]
+    df = df[df.text.map(lambda t: set(re.findall(r"\{(\w+)\}", t)) <= slots)]; n_slot = len(df)
+    real = pd.read_parquet("data/seeds_audited.parquet")                 # ALL real seeds, incl. dropped ones
+    df = df[~df.text.map(strict).isin(set(real.text.map(strict)))]
+    df = df.assign(k=df.text.map(strict)).drop_duplicates("k").drop(columns="k").sample(frac=1, random_state=a.seed).reset_index(drop=True); n_exact = len(df)
+
+    m = SentenceTransformer("BAAI/bge-small-en-v1.5")
+    E = m.encode(df.text.tolist(), batch_size=256, normalize_embeddings=True)
+    R = m.encode(real.text.tolist(), batch_size=256, normalize_embeddings=True)
+    keep = np.ones(len(df), bool)
+    keep &= (E @ R.T).max(1) < a.real_sim                                  # too close to a real seed
+    for i, g in df.groupby("intent").indices.items():                      # greedy near-dup removal within intent
+        kept = []
+        for j in g:
+            if not keep[j]: continue
+            if kept and (E[kept] @ E[j]).max() >= a.sim: keep[j] = False
+            else: kept.append(j)
+    df = df[keep].assign(ei=np.where(keep)[0]); n_near = len(df)
+
+    parts = []
+    for _, g in df.groupby("intent"):
+        nz = g[g.noise_type == "llm_noisy"].head(a.noisy_quota)
+        parts.append(pd.concat([nz, g.drop(nz.index)]).head(a.per_intent))
+    df = pd.concat(parts).reset_index(drop=True)
+
+    df["text_template"] = df.text
+    df["pii_types"] = df.text.map(lambda t: sorted({TYPES[s] for s in re.findall(r"\{(\w+)\}", t)}))
+    df["has_pii"] = df.pii_types.map(len) > 0
+    df["text"] = [fill(t, fk, rng) for t in df.text]
+    df["label"] = df.intent.astype("category").cat.codes
+
+    # stratified 1/3 train / 2/3 test; near-dup clusters (cos >= split-sim) move together
+    df["split"] = "test"
+    for _, g in df.groupby("intent"):
+        comp = components(E[g.ei.values], a.split_sim)
+        cids = list(dict.fromkeys(comp)); rng.shuffle(cids)
+        want, got = round(len(g) / 3), 0
+        for c in cids:
+            n = int((comp == c).sum())
+            if got >= want: break
+            if got + n > want + 2: continue                                # don't let a big cluster overshoot the quota
+            df.loc[g.index[comp == c], "split"] = "train"; got += n
+    cross = 0                                                              # audit: any cross-split pair above split-sim?
+    for _, g in df.groupby("intent"):
+        S = E[g.ei.values] @ E[g.ei.values].T; sp = (g.split == "train").values
+        cross += int(((S >= a.split_sim) & (sp[:, None] != sp[None, :])).sum() // 2)
+    df[["text", "text_template", "intent", "label", "has_pii", "pii_types", "noise_type", "split"]].to_parquet(a.out)
+    print(f"generated {n0} -> verified {n_ver} -> valid slots {n_slot} -> exact-dedup/not-in-real {n_exact} -> near-dedup {n_near} -> balanced {len(df)}")
+    print(f"intents={df.intent.nunique()} per-intent min/max={df.intent.value_counts().min()}/{df.intent.value_counts().max()} "
+          f"has_pii={df.has_pii.mean():.1%} train={int((df.split=='train').sum())} test={int((df.split=='test').sum())} "
+          f"cross-split pairs >= {a.split_sim}: {cross}")
+    print("noise_type:", df.noise_type.value_counts().to_dict(), "| pii_types:", df.pii_types.explode().value_counts().to_dict())
+
+if __name__ == "__main__":
+    main()

scripts/gen_synthetic.py

@@ -0,0 +1,84 @@
+"""Generate synthetic banking queries per intent with DeepSeek, seeded with real clean-pool examples."""
+import argparse, json, os, random, threading
+from concurrent.futures import ThreadPoolExecutor
+import numpy as np, pandas as pd
+from llm import chat_json, usage_line
+
+SYSTEM = """You write realistic customer messages sent to a retail bank's support chat. Given a target intent, real examples of it, and confusable OTHER intents, write NEW messages that clearly express ONLY the target intent.
+Rules:
+- Every message must be unmistakably about the target intent and must NOT be answerable as any of the confusable other intents.
+- Do not copy or lightly paraphrase the examples; vary wording, structure, length, tone, typos and punctuation as instructed by the style hint.
+- About 1 in 3 messages should include personal details, written ONLY as these placeholders (never real-looking values): {NAME} {AMOUNT} {LAST4} {MERCHANT} {CITY}. The rest must have no personal details and no placeholders.
+- One message per string, no numbering, no quotes inside unless natural.
+Return JSON: {"q": ["...", ...]}"""
+
+STYLES = ["very short and terse (3-8 words)", "one casual sentence, lowercase, a typo or two", "polite and formal, 1-2 sentences",
+          "frustrated or worried, 2 sentences", "a question phrased indirectly", "detailed, gives the backstory, 2-3 sentences",
+          "non-native English speaker phrasing", "mix of short and medium messages"]
+
+SYSTEM_NOISY = """You write realistic, MESSY customer messages sent to a retail bank's support chat, typed quickly on a phone. Given a target intent, real examples of it, and confusable OTHER intents, write NEW messages that clearly express ONLY the target intent.
+Rules:
+- Every message must still be unmistakably about the target intent and must NOT be answerable as any confusable other intent.
+- Do NOT write polished, grammatically perfect sentences. Do not copy the examples.
+- Follow the mess hint for the whole batch, but mix in variety: about 30% with typos or misspellings, about 20% very short (under 8 words), about 15% rambling run-ons, some with slang ("pls", "thx", "idk", "gonna", "bc"), some with no punctuation or "!!!" / "???", occasional mixed register.
+- About 1 in 3 messages should include personal details, written ONLY as these placeholders (never real-looking values): {NAME} {AMOUNT} {LAST4} {MERCHANT} {CITY} {DATE} {REF}. Use a placeholder only where it fits the message naturally. The rest must have no placeholders.
+- One message per string, no numbering.
+Return JSON: {"q": ["...", ...]}"""
+
+MESS = ["heavy typos and misspellings", "very short fragments, under 8 words", "rambling run-on sentences with backstory",
+        "texting slang and abbreviations, no punctuation", "frustrated, caps and !!! and ???", "mixed formal and rude register",
+        "odd or unusual word choices, non-native phrasing", "incomplete sentences and trailing off"]
+
+def neighbors(intents):
+    seeds = pd.read_parquet("data/seeds_audited.parquet")
+    emb = np.load("data/seed_emb_bge.npy")
+    cent = {i: emb[(seeds.intent == i).values].mean(0) for i in seeds.intent.unique()}
+    for k in cent: cent[k] /= np.linalg.norm(cent[k])
+    out = {}
+    for i in intents:
+        sims = sorted(((float(cent[i] @ cent[j]), j) for j in intents if j != i), reverse=True)
+        out[i] = [j for _, j in sims[:2]]
+    return out
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--per-intent", type=int, default=195)
+    ap.add_argument("--batch", type=int, default=15)
+    ap.add_argument("--intents", type=int, default=0, help="pilot: only first N intents")
+    ap.add_argument("--workers", type=int, default=12)
+    ap.add_argument("--out", default="data/synth_raw.jsonl")
+    ap.add_argument("--noisy", action="store_true", help="messy-style prompt with extra PII slots")
+    a = ap.parse_args()
+
+    pool = pd.read_parquet("data/clean_pool.parquet")
+    intents = sorted(pool.intent.unique())
+    nb = neighbors(intents)
+    by = {i: pool[pool.intent == i].text.tolist() for i in intents}
+    todo_intents = intents[: a.intents] if a.intents else intents
+    have = {i: 0 for i in intents}
+    if os.path.exists(a.out):
+        for l in open(a.out): have[json.loads(l)["intent"]] += 1
+    jobs = []
+    for i in todo_intents:
+        for _ in range(max(0, -(-(a.per_intent - have[i]) // a.batch))): jobs.append(i)
+    print(f"{len(jobs)} calls planned", flush=True)
+    lock, f = threading.Lock(), open(a.out, "a")
+
+    def run(intent):
+        rng = random.Random()
+        ex = rng.sample(by[intent], min(6, len(by[intent])))
+        user = (f"Target intent: {intent}\nReal examples:\n" + "\n".join(f"- {s}" for s in ex) +
+                "\nConfusable OTHER intents (do NOT write these):\n" +
+                "\n".join(f"- {n}, e.g. \"{rng.choice(by[n])}\"" for n in nb[intent]) +
+                f"\n\n{'Mess hint' if a.noisy else 'Style hint'}: {rng.choice(MESS if a.noisy else STYLES)}\nWrite {a.batch} new messages.")
+        qs = chat_json("deepseek-flash", SYSTEM_NOISY if a.noisy else SYSTEM, user, max_tokens=1500).get("q", [])
+        with lock:
+            for q in qs:
+                if isinstance(q, str) and q.strip(): f.write(json.dumps({"intent": intent, "text": q.strip()}) + "\n")
+            f.flush()
+
+    with ThreadPoolExecutor(a.workers) as ex: list(ex.map(run, jobs))
+    print(usage_line())
+
+if __name__ == "__main__":
+    main()

scripts/llm.py

@@ -0,0 +1,31 @@
+"""Minimal DeepSeek chat client: reasoning off, JSON output, retries, token accounting."""
+import json, os, threading, time
+import requests
+
+URL = "https://api.deepseek.com/chat/completions"
+_lock = threading.Lock()
+USAGE = {"prompt": 0, "cache_hit": 0, "completion": 0, "calls": 0}
+
+def chat_json(model, system, user, max_tokens=1200, temperature=1.0, retries=6):
+    body = {"model": model, "temperature": temperature, "max_tokens": max_tokens,
+            "thinking": {"type": "disabled"}, "response_format": {"type": "json_object"},
+            "messages": [{"role": "system", "content": system}, {"role": "user", "content": user}]}
+    for k in range(retries):
+        try:
+            r = requests.post(URL, headers={"Authorization": "Bearer " + os.environ["DEEPSEEK_API_KEY"]}, json=body, timeout=180)
+            if r.status_code == 200:
+                j = r.json()
+                u = j["usage"]
+                with _lock:
+                    USAGE["prompt"] += u["prompt_tokens"]; USAGE["completion"] += u["completion_tokens"]
+                    USAGE["cache_hit"] += u.get("prompt_cache_hit_tokens", 0); USAGE["calls"] += 1
+                return json.loads(j["choices"][0]["message"]["content"])
+            if r.status_code not in (429, 500, 502, 503, 504): raise RuntimeError(f"{r.status_code}: {r.text[:200]}")
+        except (requests.RequestException, json.JSONDecodeError):
+            pass
+        time.sleep(2 ** k)
+    raise RuntimeError("LLM call failed after retries")
+
+def usage_line():
+    u = USAGE
+    return f"calls={u['calls']} prompt={u['prompt']} (cached {u['cache_hit']}) completion={u['completion']}"

scripts/make_candidates.py

@@ -0,0 +1,61 @@
+"""v2 candidates: clean v1 rows (25% perturbed) + messy LLM rows, then PII injected up to a target rate. Labels are never touched."""
+import argparse, json, random, re
+import pandas as pd
+
+SLANG = [("please", "pls"), ("thanks", "thx"), ("because", "bc"), ("going to", "gonna"), ("want to", "wanna"), ("do not", "dont"),
+         ("cannot", "cant"), ("i am", "im"), ("you are", "ur"), ("what is", "whats"), ("i have", "ive"), ("my account", "my acct")]
+PREFIX = ["Hi, I'm {NAME}. ", "Hello, this is {NAME}. ", "{NAME} here. ", "hi its {NAME}, ", "Hi, {NAME} speaking. "]
+SUFFIX = [" My ref is {REF}.", " ref {REF}", " (account holder {NAME})", " I'm in {CITY} at the moment.", " This was on {DATE}.", " Ref: {REF}"]
+TYPES = {"NAME": "name", "AMOUNT": "amount", "LAST4": "card_digits", "MERCHANT": "merchant", "CITY": "location", "DATE": "date", "REF": "reference"}
+
+def perturb(text, rng):
+    """Light input noise: slang, typos, dropped word/punctuation, casing. Placeholders are never touched."""
+    for f, s in SLANG:
+        if rng.random() < 0.35: text = re.sub(rf"\b{f}\b", s, text, flags=re.I)
+    w = text.split()
+    for _ in range(rng.choice([1, 1, 2, 3])):
+        i = rng.randrange(len(w))
+        t = w[i]
+        if "{" in t or len(t) < 4: continue
+        j = rng.randrange(1, len(t) - 1)
+        op = rng.choice(["swap", "drop", "dup"])
+        w[i] = t[:j] + t[j + 1] + t[j] + t[j + 2:] if op == "swap" else t[:j] + t[j + 1:] if op == "drop" else t[:j] + t[j] + t[j:]
+    k = rng.randrange(1, len(w) - 1) if len(w) > 5 else 0
+    if k and rng.random() < 0.3 and "{" not in w[k]: w.pop(k)
+    text = " ".join(w)
+    if rng.random() < 0.4: text = text.rstrip("?.!")
+    if rng.random() < 0.35 and "{" not in text: text = text.lower()
+    return text
+
+def inject(text, rng):
+    if rng.random() < 0.5: return rng.choice(PREFIX) + (text if rng.random() < 0.5 else text[0].lower() + text[1:])
+    return text.rstrip() + rng.choice(SUFFIX)
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--perturb-frac", type=float, default=0.25)
+    ap.add_argument("--pii-target", type=float, default=0.32)
+    ap.add_argument("--seed", type=int, default=0)
+    ap.add_argument("--out", default="data/cand_v2.jsonl")
+    a = ap.parse_args()
+    rng = random.Random(a.seed)
+
+    clean = pd.read_json("data/synth_verified.jsonl", lines=True)
+    clean = clean[clean.verified][["intent", "text"]].assign(noise_type="clean")
+    noisy = pd.read_json("data/synth_raw_v2.jsonl", lines=True).assign(noise_type="llm_noisy")
+    pert = clean.sample(frac=a.perturb_frac, random_state=a.seed)
+    clean = clean.drop(pert.index)
+    pert = pert.assign(text=[perturb(t, rng) for t in pert.text], noise_type="perturbed")
+    df = pd.concat([clean, pert, noisy], ignore_index=True)
+
+    has = df.text.str.contains(r"\{\w+\}")
+    need = int(a.pii_target * len(df)) - int(has.sum())
+    cand = df.index[~has].tolist()
+    rng.shuffle(cand)
+    for i in cand[:max(0, need)]: df.at[i, "text"] = inject(df.at[i, "text"], rng)
+    after = df.text.str.contains(r"\{\w+\}").mean()
+    print(f"rows={len(df)} noise_type={df.noise_type.value_counts().to_dict()} pii_rate {has.mean():.1%} -> {after:.1%}")
+    df.to_json(a.out, orient="records", lines=True)
+
+if __name__ == "__main__":
+    main()

scripts/prep_seeds.py

@@ -0,0 +1,49 @@
+"""Pool Banking77, dedup, and flag likely-mislabeled seeds via cross-validated confident learning."""
+import re
+import unicodedata
+import numpy as np
+import pandas as pd
+from datasets import load_dataset
+from sentence_transformers import SentenceTransformer
+from sklearn.linear_model import LogisticRegression
+from sklearn.model_selection import cross_val_predict, StratifiedKFold
+from cleanlab.filter import find_label_issues
+
+def norm(s):
+    """NFKC + casefold + keep alphanumerics only (no spaces), so 'top-up' == 'top up' == 'topup'."""
+    return re.sub(r"[\W_]+", "", unicodedata.normalize("NFKC", s).casefold())
+
+def main():
+    ds = load_dataset("legacy-datasets/banking77")
+    names = ds["train"].features["label"].names
+    df = pd.concat([ds["train"].to_pandas().assign(orig_split="train"),
+                    ds["test"].to_pandas().assign(orig_split="test")], ignore_index=True)
+    df["intent"] = df["label"].map(dict(enumerate(names)))
+    df["norm"] = df["text"].map(norm)
+    print(f"pooled: {len(df)}")
+
+    # exact duplicates after normalization; report label conflicts (same text, different intent)
+    grp = df.groupby("norm")["label"].nunique()
+    print(f"norm-duplicate groups: {(df.duplicated('norm', keep=False)).sum()} rows, "
+          f"{(grp > 1).sum()} texts with conflicting labels")
+    df = df[~df["norm"].isin(grp[grp > 1].index)]          # ambiguous text: drop entirely
+    df = df.drop_duplicates("norm", keep="first").reset_index(drop=True)
+    print(f"after exact dedup: {len(df)}")
+
+    emb = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2").encode(
+        df["text"].tolist(), batch_size=256, normalize_embeddings=True, show_progress_bar=False)
+    probs = cross_val_predict(LogisticRegression(max_iter=2000, C=10), emb, df["label"],
+                              cv=StratifiedKFold(5, shuffle=True, random_state=0), method="predict_proba")
+    issues = find_label_issues(df["label"].values, probs, return_indices_ranked_by="self_confidence")
+    df["suspect"] = False
+    df.loc[issues, "suspect"] = True
+    df["cv_pred"] = probs.argmax(1)
+    df["cv_conf_true"] = probs[np.arange(len(df)), df["label"]]
+    print(f"suspect seeds: {df.suspect.sum()} ({df.suspect.mean():.1%})")
+    print("top intents by suspect rate:\n", df.groupby("intent").suspect.mean().sort_values(ascending=False).head(8).round(2))
+    df.drop(columns=["label"]).assign(label=df["label"]).to_parquet("data/seeds.parquet")
+    np.save("data/seed_emb.npy", emb)
+
+
+if __name__ == "__main__":
+    main()

scripts/select_clean.py

@@ -0,0 +1,48 @@
+"""Build the clean real-seed pool (~9k): drop noisy/conflicting rows, then prune hub intents of the confusion graph."""
+import sys
+from collections import Counter
+import numpy as np, pandas as pd
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.neighbors import NearestNeighbors
+
+TARGET = int(sys.argv[1]) if len(sys.argv) > 1 else 9000
+
+def main():
+    d = pd.read_parquet("data/seeds_audited.parquet")
+    d["votes"] = d.suspect.astype(int) + d.lr_bad.astype(int) + d.knn_bad.astype(int)
+    p = np.load("data/seed_cvprob_bge.npy")
+    d["cv_pred"] = p.argmax(1)
+
+    # row-level: any detector flag, or in a near-duplicate pair with a different label
+    X = TfidfVectorizer(analyzer="char_wb", ngram_range=(3, 5), sublinear_tf=True).fit_transform(d.text.str.lower())
+    dist, idx = NearestNeighbors(n_neighbors=4, metric="cosine").fit(X).kneighbors(X)
+    conflict = np.zeros(len(d), bool)
+    for i in range(len(d)):
+        for dj, j in zip(dist[i, 1:], idx[i, 1:]):
+            if 1 - dj >= 0.85 and d.label.values[i] != d.label.values[j]: conflict[i] = conflict[j] = True
+    d["conflict_nd"] = conflict
+    keep = d[(d.votes == 0) & ~d.conflict_nd].copy()
+    print(f"row-level: {len(d)} -> {len(keep)} (flagged {int((d.votes>0).sum())}, conflicting near-dup {int(conflict.sum())})")
+
+    # intent-level: confusion graph from CV predictions on the rows we kept; drop hub intents greedily
+    kk = keep[keep.cv_pred != keep.label]
+    mass = Counter()
+    edges = Counter()
+    for a, b in zip(kk.intent, kk.cv_pred.map(dict(zip(d.label, d.intent)))):
+        edges[a] += 1; edges[b] += 1; mass[tuple(sorted((a, b)))] += 1
+    dropped = []
+    while len(keep) > TARGET:
+        deg = Counter()
+        for (a, b), n in mass.items(): deg[a] += n; deg[b] += n
+        if not deg: break
+        worst = deg.most_common(1)[0][0]
+        dropped.append((worst, int(deg[worst]), int((keep.intent == worst).sum())))
+        keep = keep[keep.intent != worst]
+        mass = Counter({k: v for k, v in mass.items() if worst not in k})
+    print(f"intent-level: dropped {len(dropped)} intents -> {len(keep)} rows, {keep.intent.nunique()} intents")
+    for n, m, r in dropped: print(f"  drop {n:45s} confusion={m:3d} rows={r}")
+    keep.drop(columns=["cv_pred"]).to_parquet("data/clean_pool.parquet")
+    print("per-intent rows: min", keep.intent.value_counts().min(), "max", keep.intent.value_counts().max())
+
+if __name__ == "__main__":
+    main()

scripts/verify_seeds.py

@@ -0,0 +1,86 @@
+"""Independent audit of data/seeds.parquet: different source, normalization, and detectors than prep_seeds.py."""
+import re, unicodedata, itertools
+import numpy as np, pandas as pd
+from huggingface_hub import hf_hub_download
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.neighbors import NearestNeighbors
+from sklearn.linear_model import LogisticRegression
+from sklearn.model_selection import cross_val_predict, StratifiedKFold
+from sentence_transformers import SentenceTransformer
+
+def strict(s):  # NFKC + casefold + alnum only (no spaces at all)
+    return re.sub(r"[\W_]+", "", unicodedata.normalize("NFKC", s).casefold())
+
+def main():
+    # ---- independent source: mteb/banking77 jsonl
+    raw = pd.concat([pd.read_json(hf_hub_download("mteb/banking77", f"{s}.jsonl", repo_type="dataset"), lines=True).assign(orig_split=s)
+                     for s in ("train", "test")], ignore_index=True)
+    print("mteb columns:", list(raw.columns), "rows:", len(raw))
+    raw = raw.rename(columns={c: "intent" for c in raw.columns if c in ("label_text", "intent")})
+    saved = pd.read_parquet("data/seeds.parquet")
+
+    print("\n== 1. SOURCE CROSS-CHECK")
+    a, b = set(map(strict, raw["text"])), set(map(strict, saved["text"]))
+    print(f"unique(strict) mteb={len(a)} saved={len(b)}  only-in-mteb={len(a-b)} only-in-saved={len(b-a)}")
+
+    print("\n== 2. EXACT DUPLICATES (strict norm, space-free)")
+    print("saved rows:", len(saved), " unique strict:", saved["text"].map(strict).nunique())
+    print("saved unique bag-of-words (order-insensitive):", saved["text"].map(lambda s: " ".join(sorted(re.findall(r"\w+", s.lower())))).nunique())
+    d = raw[raw["text"].map(strict).duplicated(keep=False)]
+    print(f"raw dup rows: {len(d)}; spanning train/test: {d.groupby(d['text'].map(strict)).orig_split.nunique().gt(1).sum()} groups; label-conflicting:",
+          d.groupby(d['text'].map(strict)).intent.nunique().gt(1).sum())
+
+    print("\n== 3. NEAR DUPLICATES (char 3-5gram TF-IDF cosine) in saved set")
+    X = TfidfVectorizer(analyzer="char_wb", ngram_range=(3, 5), sublinear_tf=True).fit_transform(saved["text"].str.lower())
+    nn = NearestNeighbors(n_neighbors=4, metric="cosine").fit(X)
+    dist, idx = nn.kneighbors(X)
+    pairs = {}
+    for i in range(len(saved)):
+        for dj, j in zip(dist[i, 1:], idx[i, 1:]):
+            sim = 1 - dj
+            if sim >= 0.85 and i != j: pairs[tuple(sorted((i, j)))] = sim
+    P = pd.DataFrame([(i, j, s) for (i, j), s in pairs.items()], columns=["i", "j", "sim"])
+    P["same_label"] = saved.label.values[P.i] == saved.label.values[P.j]
+    P["cross_split"] = saved.orig_split.values[P.i] != saved.orig_split.values[P.j]
+    for t in (0.85, 0.9, 0.95):
+        q = P[P.sim >= t]
+        print(f"sim>={t}: {len(q)} pairs | cross orig train/test: {q.cross_split.sum()} | DIFFERENT labels: {(~q.same_label).sum()}")
+    diff = P[~P.same_label].sort_values("sim", ascending=False)
+    print("\n-- near-identical pairs with DIFFERENT labels (model-free evidence of ambiguity):")
+    for _, r in diff.head(15).iterrows():
+        print(f"  {r.sim:.2f} | {saved.text[r.i]!r} [{saved.intent[r.i]}]  <->  {saved.text[r.j]!r} [{saved.intent[r.j]}]")
+    print(f"total conflicting near-dup pairs @0.85: {len(diff)}; distinct rows involved: {len(set(diff.i)|set(diff.j))}")
+
+    print("\n== 4. INDEPENDENT LABEL AUDIT")
+    emb = SentenceTransformer("BAAI/bge-small-en-v1.5").encode(saved["text"].tolist(), batch_size=256, normalize_embeddings=True)
+    y = saved.label.values
+    cv = StratifiedKFold(5, shuffle=True, random_state=123)
+    p_lr = cross_val_predict(LogisticRegression(max_iter=3000, C=20), emb, y, cv=cv, method="predict_proba")
+    # kNN vote (k=10, leave-self-out) as a second, non-parametric detector
+    knn = NearestNeighbors(n_neighbors=11, metric="cosine").fit(emb)
+    _, kidx = knn.kneighbors(emb)
+    vote_true = np.array([(y[kidx[i, 1:]] == y[i]).mean() for i in range(len(y))])
+    lr_bad = p_lr[np.arange(len(y)), y] < 0.1
+    knn_bad = vote_true == 0
+    both = lr_bad & knn_bad
+    prev = saved.suspect.values
+    print(f"LR(bge) true-label prob<0.1: {lr_bad.sum()} | kNN 0/10 neighbours agree: {knn_bad.sum()} | both: {both.sum()}")
+    print(f"previous flags (cleanlab+MiniLM): {prev.sum()} | overlap with 'both': {(prev & both).sum()} | overlap with either: {(prev & (lr_bad | knn_bad)).sum()}")
+    # original protocol check: train on original train, predict original test
+    tr, te = (saved.orig_split == "train").values, (saved.orig_split == "test").values
+    clf = LogisticRegression(max_iter=3000, C=20).fit(emb[tr], y[tr])
+    print(f"train->test accuracy (bge+LR): {(clf.predict(emb[te]) == y[te]).mean():.3f}  (a very low value would signal noisy test labels)")
+
+    print("\n-- 25 random rows flagged by BOTH new detectors (read them yourself):")
+    names = saved.intent.values
+    cls = dict(zip(saved.label, saved.intent))
+    for i in np.random.default_rng(0).permutation(np.where(both)[0])[:25]:
+        print(f"  {saved.text[i]!r}  labeled={names[i]}  model says={cls[p_lr[i].argmax()]}  prev_flag={prev[i]}")
+    print("\n-- 10 random rows flagged by previous pass but NOT by new detectors:")
+    for i in np.random.default_rng(1).permutation(np.where(prev & ~(lr_bad | knn_bad))[0])[:10]:
+        print(f"  {saved.text[i]!r}  labeled={names[i]}  model says={cls[p_lr[i].argmax()]}")
+    out = saved.assign(lr_bad=lr_bad, knn_bad=knn_bad, both_bad=both)
+    out.to_parquet("data/seeds_audited.parquet")
+
+if __name__ == "__main__":
+    main()

scripts/verify_synthetic.py

@@ -0,0 +1,58 @@
+"""Independent label check: deepseek-v4-pro classifies each generated query among the intents; keep only agreeing rows.
+Also calibrates the verifier on held-out REAL rows so we know its ceiling."""
+import argparse, json
+from concurrent.futures import ThreadPoolExecutor
+import pandas as pd
+from llm import chat_json, usage_line
+
+def build_system(intents, examples):
+    listing = "\n".join(f"{k}: {n} | e.g. " + " / ".join(examples[n]) for k, n in enumerate(intents))
+    return ("You classify messages sent to a retail bank's support chat into exactly one intent. Intents (id: name | examples):\n"
+            f"{listing}\n\nFor each numbered message choose the single best-fitting intent id. Placeholders like {{NAME}} are fake personal details; ignore them. "
+            'Return JSON {"a": [id, id, ...]} with exactly one id per message, in order.')
+
+def classify(system, texts, model):
+    user = "\n".join(f"{i+1}. {t}" for i, t in enumerate(texts))
+    a = chat_json(model, system, user, max_tokens=400, temperature=0.0).get("a", [])
+    if len(a) == len(texts): return a
+    if len(texts) == 1: return [-1]
+    h = len(texts) // 2
+    return classify(system, texts[:h], model) + classify(system, texts[h:], model)
+
+def run(system, df, model, batch, workers):
+    chunks = [df.text.tolist()[i:i + batch] for i in range(0, len(df), batch)]
+    with ThreadPoolExecutor(workers) as ex: res = list(ex.map(lambda c: classify(system, c, model), chunks))
+    return [x for r in res for x in r]
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--inp", default="data/synth_raw.jsonl")
+    ap.add_argument("--out", default="data/synth_verified.jsonl")
+    ap.add_argument("--model", default="deepseek-v4-pro")
+    ap.add_argument("--batch", type=int, default=40)
+    ap.add_argument("--workers", type=int, default=8)
+    ap.add_argument("--calibrate", type=int, default=0, help="only score N held-out real rows, then exit")
+    a = ap.parse_args()
+
+    pool = pd.read_parquet("data/clean_pool.parquet")
+    intents = sorted(pool.intent.unique())
+    ex_rows = pool.groupby("intent").sample(2, random_state=0)          # in-prompt examples
+    examples = {i: g.text.tolist() for i, g in ex_rows.groupby("intent")}
+    system = build_system(intents, examples)
+    idx = {n: k for k, n in enumerate(intents)}
+
+    if a.calibrate:
+        held = pool.drop(ex_rows.index).sample(a.calibrate, random_state=1)
+        pred = run(system, held, a.model, a.batch, a.workers)
+        acc = (pd.Series(pred).values == held.intent.map(idx).values).mean()
+        print(f"verifier accuracy on {len(held)} held-out REAL rows: {acc:.3f}\n{usage_line()}")
+        return
+
+    df = pd.read_json(a.inp, lines=True)
+    df["pred"] = run(system, df, a.model, a.batch, a.workers)
+    df["verified"] = df.pred == df.intent.map(idx)
+    df.to_json(a.out, orient="records", lines=True)
+    print(f"verified {df.verified.mean():.1%} of {len(df)}\n{df.groupby('intent').verified.mean().sort_values().head(8).round(2)}\n{usage_line()}")
+
+if __name__ == "__main__":
+    main()

seeds/seeds_audited.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:54db7fa3e4e6a0efb174863e4116b37a385e150d8d0f29c7a6dd5a25d42f9dcf
+size 383141