| """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: |
| |
| 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))] |
| |
| sf1 = f1_score(labels, pred_label, zero_division=0) |
| sent_f1s.append(sf1) |
| |
| 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)}") |
|
|
| |
| print("\n[1/2] Rule (longest cue-containing sentence)") |
| rule_res = evaluate_predictor(test_pos, rule_predict, 'Rule(cue+longest)') |
|
|
| |
| 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() |
|
|
