"""CP-11: Span-extraction baseline. For each gold-test positive (which has aligned `suggestion_span` in `text`), predict the suggestion-bearing sentence(s) within the review. Baselines: Rule: return the longest sentence containing any cue regex. TF-IDF + sentence-classifier: train a sentence-level classifier on (sentence, label_from_span_alignment) where label=1 if sentence overlaps with the suggestion span >50% of its words. Metrics: Sentence-level F1 of suggestion-bearing sentence prediction. Span-level F1: token-overlap F1 between predicted and gold span. Saves work/results/span_extraction.json. """ from __future__ import annotations import json, re from pathlib import Path import numpy as np import pandas as pd from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.linear_model import LogisticRegression from sklearn.metrics import f1_score ROOT = Path("/home/aniket/praxis-benchmark") WORK = ROOT / "work" DATA = WORK / "data" RES = WORK / "results" CUE_PATTERN = re.compile( r"\b(would|wish(?:ed)?|should|could|need(?:s|ed)?|must|please|hope(?:d)?|" r"recommend(?:s|ed|ing)?|suggest(?:s|ed|ing)?|if|why don't|why not|" r"have to|got to|gotta)\b", re.IGNORECASE) def split_sentences(text): if not text: return [] parts = re.split(r"(?<=[\.!?])\s+", str(text)) return [p.strip() for p in parts if p.strip()] def normalize(text): return re.sub(r"[^a-z0-9 ]", " ", str(text).lower()) def token_overlap_f1(a, b): a_set = set(normalize(a).split()) b_set = set(normalize(b).split()) if not a_set or not b_set: return 0.0 inter = a_set & b_set if not inter: return 0.0 p = len(inter) / len(b_set) r = len(inter) / len(a_set) return 2 * p * r / (p + r) def label_sentences_from_span(sentences, span): if not span or span == 'NONE': return [0] * len(sentences) span_norm = normalize(span) span_toks = set(span_norm.split()) if not span_toks: return [0] * len(sentences) labels = [] for s in sentences: s_toks = set(normalize(s).split()) if not s_toks: labels.append(0); continue overlap = len(span_toks & s_toks) / len(s_toks) if s_toks else 0 labels.append(1 if overlap >= 0.5 else 0) if sum(labels) == 0: # Fallback: max-overlap sentence ovs = [len(span_toks & set(normalize(s).split())) for s in sentences] if max(ovs) > 0: labels[ovs.index(max(ovs))] = 1 return labels def rule_predict(sentences): """Return index of longest sentence containing a cue, or -1.""" candidates = [(i, len(s)) for i, s in enumerate(sentences) if CUE_PATTERN.search(s)] if not candidates: return -1 return max(candidates, key=lambda x: x[1])[0] def evaluate_predictor(test_pos, predict_fn, name): """predict_fn(sentences) -> predicted index of suggestion sentence (-1 = none).""" sent_f1s, span_f1s = [], [] pred_correct = 0 n_evaluated = 0 for _, row in test_pos.iterrows(): sentences = split_sentences(row['text']) if not sentences: continue gold_span = row.get('suggestion_span', '') labels = label_sentences_from_span(sentences, gold_span) if sum(labels) == 0: continue pred_idx = predict_fn(sentences) if pred_idx < 0: sent_f1s.append(0.0); span_f1s.append(0.0); n_evaluated += 1; continue pred_label = [1 if i == pred_idx else 0 for i in range(len(sentences))] # sentence-level F1 sf1 = f1_score(labels, pred_label, zero_division=0) sent_f1s.append(sf1) # span-level token overlap F1 sf = token_overlap_f1(gold_span, sentences[pred_idx]) span_f1s.append(sf) if labels[pred_idx] == 1: pred_correct += 1 n_evaluated += 1 return { 'name': name, 'n_evaluated': n_evaluated, 'sentence_accuracy': pred_correct / max(n_evaluated, 1), 'sentence_f1_mean': float(np.mean(sent_f1s)) if sent_f1s else 0, 'span_token_overlap_f1_mean': float(np.mean(span_f1s)) if span_f1s else 0, } def main(): print("=" * 70); print("CP-11: Span extraction baselines"); print("=" * 70) test = pd.read_csv(DATA / "gold_test.csv", low_memory=False) test['is_suggestion'] = test['is_suggestion'].astype(str).str.lower().isin(['true', '1']) test['text'] = test['text'].fillna('').astype(str) test['suggestion_span'] = test['suggestion_span'].fillna('NONE').astype(str) test_pos = test[test['is_suggestion']].reset_index(drop=True) print(f"Positive test rows: {len(test_pos)}") train_dev = pd.concat([ pd.read_csv(DATA / "gold_train.csv", low_memory=False), pd.read_csv(DATA / "gold_dev.csv", low_memory=False), ]) train_dev['is_suggestion'] = train_dev['is_suggestion'].astype(str).str.lower().isin(['true', '1']) train_dev['text'] = train_dev['text'].fillna('').astype(str) train_dev['suggestion_span'] = train_dev['suggestion_span'].fillna('NONE').astype(str) train_pos = train_dev[train_dev['is_suggestion']].reset_index(drop=True) print(f"Positive train rows: {len(train_pos)}") # ---- Baseline 1: Rule ---- print("\n[1/2] Rule (longest cue-containing sentence)") rule_res = evaluate_predictor(test_pos, rule_predict, 'Rule(cue+longest)') # ---- Baseline 2: TF-IDF sentence classifier ---- print("\n[2/2] TF-IDF + LR sentence classifier") sentences_train, labels_train = [], [] for _, row in train_pos.iterrows(): sents = split_sentences(row['text']) labs = label_sentences_from_span(sents, row['suggestion_span']) sentences_train.extend(sents) labels_train.extend(labs) print(f" train sents: {len(sentences_train)} ({sum(labels_train)} positive)") vec = TfidfVectorizer(ngram_range=(1, 2), min_df=2, max_df=0.9, sublinear_tf=True) X_train = vec.fit_transform(sentences_train) clf = LogisticRegression(C=1.0, max_iter=1500, class_weight='balanced') clf.fit(X_train, labels_train) def tfidf_predict(sentences): if not sentences: return -1 X = vec.transform(sentences) scores = clf.predict_proba(X)[:, 1] return int(np.argmax(scores)) tfidf_res = evaluate_predictor(test_pos, tfidf_predict, 'TF-IDF+LR sentence classifier') results = {'Rule_cue_longest': rule_res, 'TFIDF_LR_sentence': tfidf_res} print("\n--- Span extraction results ---") for k, v in results.items(): print(f" {k}: sent-F1 {v['sentence_f1_mean']:.3f} span-token-F1 {v['span_token_overlap_f1_mean']:.3f} " f"sent-acc {v['sentence_accuracy']:.3f} (n={v['n_evaluated']})") (RES / "span_extraction.json").write_text(json.dumps(results, indent=2)) print("CP-11 DONE.") if __name__ == '__main__': main()