| """CP-10: Slice evaluation — analyze per-form, per-modifier, per-borderline, |
| per-specificity, per-industry, and length-bucket performance. |
| |
| Reads predictions from work/models/preds_*.csv (HF-LLM outputs) and the trained-encoder |
| predictions from work/models/<model>/test_predictions_seed*.csv. |
| |
| Outputs work/results/slices.json, plus heatmaps in work/figures/. |
| """ |
| from __future__ import annotations |
| import json, ast, glob |
| from pathlib import Path |
| import numpy as np |
| import pandas as pd |
| from sklearn.metrics import f1_score, accuracy_score |
| import matplotlib |
| matplotlib.use("Agg") |
| import matplotlib.pyplot as plt |
|
|
| ROOT = Path("/home/aniket/praxis-benchmark") |
| WORK = ROOT / "work" |
| DATA = WORK / "data" |
| RES = WORK / "results" |
| FIG = WORK / "figures" |
| MODELS = WORK / "models" |
|
|
|
|
| def parse_list(s): |
| if isinstance(s, list): return s |
| if pd.isna(s): return [] |
| try: |
| x = ast.literal_eval(str(s)) |
| if isinstance(x, list): return x |
| except Exception: pass |
| return [] |
|
|
|
|
| def load_test(): |
| g = pd.read_csv(DATA / "gold_test.csv", low_memory=False) |
| g['is_suggestion'] = g['is_suggestion'].astype(str).str.lower().isin(['true','1']) |
| g['borderline'] = g['borderline'].astype(str).str.lower().isin(['true','1']) |
| g['true'] = g['is_suggestion'].astype(int) |
| g['tier2_list'] = g['tier2_modifiers'].apply(parse_list) |
| g['text'] = g['text'].fillna('').astype(str) |
| g['n_words'] = g['text'].str.split().apply(len) |
| |
| if 'gold_id' in g.columns and 'praxis_id' not in g.columns: |
| g['praxis_id'] = g['gold_id'] |
| return g |
|
|
|
|
| def find_preds(): |
| out = {} |
| |
| for f in glob.glob(str(MODELS / "*/test_predictions_seed*.csv")): |
| p = Path(f) |
| model = p.parent.name |
| seed = p.stem.split('seed')[-1] |
| try: |
| df = pd.read_csv(p) |
| out.setdefault(f"enc_{model}", []).append((seed, df)) |
| except Exception: |
| pass |
| |
| for f in glob.glob(str(MODELS / "preds_hf_*.csv")): |
| p = Path(f) |
| try: |
| df = pd.read_csv(p) |
| mname = p.stem.replace('preds_hf_', '') |
| out[f"llm_{mname}"] = [('zs', df)] |
| except Exception: |
| pass |
| return out |
|
|
|
|
| def macro_f1(true, pred): |
| return float(f1_score(true, pred, average='macro', zero_division=0)) |
|
|
|
|
| def per_form(g, preds): |
| out = {} |
| for form in ['Direct imperative', 'Modal/deontic', 'Conditional', 'Optative', |
| 'Interrogative', 'Comparative']: |
| sub = g[g['tier1_form'] == form] |
| if len(sub) < 5: continue |
| m = sub['praxis_id'].isin(preds.index) if 'praxis_id' in sub.columns else None |
| |
| merged = sub.merge(preds.reset_index(), on='praxis_id', how='inner') |
| if len(merged) == 0: continue |
| |
| recall = float(((merged['pred'] == 1) & (merged['true'] == 1)).sum() / |
| max((merged['true'] == 1).sum(), 1)) |
| out[form] = {'n': int(len(merged)), 'recall': recall} |
| return out |
|
|
|
|
| def per_modifier(g, preds): |
| out = {} |
| for mod in ['Frustrated', 'Hedged', 'Backhanded', 'Sarcastic']: |
| mask = g['tier2_list'].apply(lambda l: mod in l) |
| sub = g[mask & (g['true'] == 1)] |
| merged = sub.merge(preds.reset_index(), on='praxis_id', how='inner') |
| if len(merged) < 5: continue |
| out[mod] = {'n': int(len(merged)), |
| 'recall': float((merged['pred'] == 1).mean())} |
| return out |
|
|
|
|
| def per_specificity(g, preds): |
| out = {} |
| for spec in ['Vague', 'Specific', 'Very specific']: |
| sub = g[(g['tier3_specificity'] == spec) & (g['true'] == 1)] |
| merged = sub.merge(preds.reset_index(), on='praxis_id', how='inner') |
| if len(merged) < 5: continue |
| out[spec] = {'n': int(len(merged)), |
| 'recall': float((merged['pred'] == 1).mean())} |
| return out |
|
|
|
|
| def per_borderline(g, preds): |
| out = {} |
| for label, val in [('borderline', True), ('clear', False)]: |
| sub = g[(g['borderline'].astype(bool) == val) & (g['true'] == 1)] |
| merged = sub.merge(preds.reset_index(), on='praxis_id', how='inner') |
| if len(merged) < 5: continue |
| out[label] = {'n': int(len(merged)), |
| 'recall': float((merged['pred'] == 1).mean())} |
| return out |
|
|
|
|
| def per_macro(g, preds): |
| out = {} |
| for macro in g['macro_domain'].dropna().unique(): |
| sub = g[g['macro_domain'] == macro] |
| merged = sub.merge(preds.reset_index(), on='praxis_id', how='inner') |
| if len(merged) < 20: continue |
| out[macro] = { |
| 'n': int(len(merged)), |
| 'macro_f1': macro_f1(merged['true'], merged['pred']), |
| 'pos_f1': float(f1_score(merged['true'], merged['pred'], pos_label=1, zero_division=0)), |
| } |
| return out |
|
|
|
|
| def per_length(g, preds, n_buckets=4): |
| out = {} |
| qs = g['n_words'].quantile(np.linspace(0, 1, n_buckets + 1)).values |
| for i in range(n_buckets): |
| lo, hi = qs[i], qs[i + 1] |
| sub = g[(g['n_words'] >= lo) & (g['n_words'] <= hi if i == n_buckets - 1 else g['n_words'] < hi)] |
| merged = sub.merge(preds.reset_index(), on='praxis_id', how='inner') |
| if len(merged) < 20: continue |
| out[f'L{i+1}_[{int(lo)}-{int(hi)}]'] = { |
| 'n': int(len(merged)), |
| 'macro_f1': macro_f1(merged['true'], merged['pred']), |
| } |
| return out |
|
|
|
|
| def per_industry(g, preds, min_n=20): |
| out = {} |
| for ind, sub in g.groupby('industry'): |
| merged = sub.merge(preds.reset_index(), on='praxis_id', how='inner') |
| if len(merged) < min_n: continue |
| if len(set(merged['true'])) < 2: continue |
| out[ind] = {'n': int(len(merged)), |
| 'macro_f1': macro_f1(merged['true'], merged['pred'])} |
| return out |
|
|
|
|
| def main(): |
| print("=" * 70); print("CP-10: Slice evaluation"); print("=" * 70) |
| g = load_test() |
| preds_dict = find_preds() |
| print(f"Loaded gold-test {len(g)} rows; preds for {len(preds_dict)} models") |
|
|
| results = {} |
| for model_name, runs in preds_dict.items(): |
| |
| if len(runs) == 1: |
| df = runs[0][1] |
| df['true'] = df['is_suggestion'].astype(str).str.lower().isin(['true','1']).astype(int) \ |
| if 'is_suggestion' in df.columns else df.get('label', 0) |
| else: |
| |
| seed_dfs = [r[1] for r in runs] |
| base = seed_dfs[0][['praxis_id', 'is_suggestion']].copy() |
| for i, sdf in enumerate(seed_dfs): |
| base[f'pred_s{i}'] = sdf.set_index('praxis_id').loc[base['praxis_id']]['pred'].values |
| base['pred'] = base[[f'pred_s{i}' for i in range(len(seed_dfs))]].mean(axis=1).round().astype(int) |
| base['true'] = base['is_suggestion'].astype(str).str.lower().isin(['true','1']).astype(int) |
| df = base[['praxis_id', 'true', 'pred']] |
|
|
| |
| if 'praxis_id' not in df.columns: |
| print(f" skip {model_name}: no praxis_id") |
| continue |
| df = df[['praxis_id', 'pred']].set_index('praxis_id') |
|
|
| |
| merged_full = g.merge(df.reset_index(), on='praxis_id', how='inner') |
| if len(merged_full) == 0: |
| print(f" skip {model_name}: no overlap (test_n={len(g)})") |
| continue |
|
|
| results[model_name] = { |
| 'n_overlap': int(len(merged_full)), |
| 'overall': { |
| 'macro_f1': macro_f1(merged_full['true'], merged_full['pred']), |
| 'pos_f1': float(f1_score(merged_full['true'], merged_full['pred'], pos_label=1, zero_division=0)), |
| }, |
| 'per_form_recall': per_form(g, df), |
| 'per_modifier_recall': per_modifier(g, df), |
| 'per_specificity_recall': per_specificity(g, df), |
| 'per_borderline_recall': per_borderline(g, df), |
| 'per_macro': per_macro(g, df), |
| 'per_length': per_length(g, df), |
| 'per_industry': per_industry(g, df), |
| } |
| print(f" {model_name}: macro-F1 {results[model_name]['overall']['macro_f1']:.4f}, n_overlap={len(merged_full)}") |
|
|
| (RES / "slices.json").write_text(json.dumps(results, indent=2, default=str)) |
| print(f"\nSaved {RES}/slices.json") |
| print("CP-10 DONE.") |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
