Enhance RSA data handling: parse listener/speaker distributions from CSV, integrate into review metadata, and update visualization logic for improved agreement representation.

interface/Demo.py

@@ -1067,7 +1067,10 @@ with gr.Blocks(title="ReView", css=CUSTOM_CSS) as demo:
                 review_sentence_lists.append([s for s, _ in review_item])
                 review_items_cache.append((review_item, rebuttal_html))
 
-            # For agreement mode, build uniqueness dict upfront for render_agreement_html
+            # For agreement mode, build uniqueness dict and extract RSA distributions
+            # RSA listener/speaker come from metadata (if pipeline saved them)
+            prep_listener = None
+            prep_speaker = None
             if show_consensuality:
                 for idx in range(number_of_displayed_reviews):
                     review_item, _ = review_items_cache[idx]
@@ -1080,7 +1083,23 @@ with gr.Blocks(title="ReView", css=CUSTOM_CSS) as demo:
                         if not is_noise_sentence(sentence) and abs(score) >= HIGHLIGHT_THRESHOLD:
                             consensuality_dict[sentence] = score
 
+                # Extract listener/speaker from metadata (saved by pipeline)
+                meta_for_year = state.get("metadata_for_year", {})
+                submission_meta = meta_for_year.get(current_id, {})
+                if isinstance(submission_meta, dict):
+                    rsa_data = submission_meta.get("rsa", {})
+                    if rsa_data:
+                        prep_listener = rsa_data.get("listener")
+                        prep_speaker = rsa_data.get("speaker")
+
             agreement_updates = []
+            divergent_per_review = {}
+            # Pre-compute per-review divergent cards if we have RSA data
+            if show_consensuality and prep_listener and prep_speaker and consensuality_dict:
+                divergent_per_review = format_divergent_cards(
+                    consensuality_dict, review_sentence_lists, prep_listener, prep_speaker,
+                )
+
             for i in range(10):
                 if i < number_of_displayed_reviews:
                     review_item, rebuttal_html = review_items_cache[i]
@@ -1128,10 +1147,13 @@ with gr.Blocks(title="ReView", css=CUSTOM_CSS) as demo:
                         sentences_for_review = [s for s, _ in review_item]
                         agreement_html = render_agreement_html(
                             sentences_for_review, consensuality_dict,
-                            listener={}, speaker={},
+                            listener=prep_listener, speaker=prep_speaker,
                             num_reviews=number_of_displayed_reviews,
                             label=f"Agreement in Review {i + 1}",
                         )
+                        # Append per-review divergent cards (if RSA data available)
+                        if i in divergent_per_review:
+                            agreement_html += divergent_per_review[i]
                         agreement_updates.append(gr.update(visible=True, value=agreement_html))
                     else:
                         agreement_updates.append(gr.update(visible=False, value=""))
@@ -1154,13 +1176,31 @@ with gr.Blocks(title="ReView", css=CUSTOM_CSS) as demo:
             general_rebuttal_update = gr.update(visible=False, value="")
 
             # Set most common opinions (as HTML cards with context)
-            # Most Unique/Divergent is hidden at top level — consistent with
-            # the interactive tab which embeds divergent cards per-review.
+            # Uses entropy-based ranking when listener data is available (like interactive tab)
             if show_consensuality and consensuality_dict:
                 scores = pd.Series(consensuality_dict)
-                most_common = scores.sort_values(ascending=True).head(5).index.tolist()
 
-                most_common_html = format_summary_cards(most_common, consensuality_dict, review_sentence_lists, "common")
+                if prep_listener:
+                    # Entropy-based ranking: same logic as interactive tab
+                    n_seed = min(15, len(scores))
+                    seed = scores.nsmallest(n_seed).index.tolist()
+
+                    def _listener_entropy(sent):
+                        dist = prep_listener.get(sent, {})
+                        ent = 0.0
+                        for p in dist.values():
+                            if p > 0:
+                                ent -= p * math.log(p)
+                        return ent
+                    seed.sort(key=_listener_entropy, reverse=True)
+                    most_common = seed[:5]
+                else:
+                    most_common = scores.sort_values(ascending=True).head(5).index.tolist()
+
+                most_common_html = format_summary_cards(
+                    most_common, consensuality_dict, review_sentence_lists, "common",
+                    listener=prep_listener, speaker=prep_speaker,
+                )
 
                 most_common_visibility = gr.update(visible=True, value=most_common_html)
                 most_unique_visibility = gr.update(visible=False, value="")

pipeline/run_glimpse_scoring.py

@@ -153,7 +153,8 @@ def convert_pk_to_csv(pickle_path: Path,
     if not isinstance(results, list):
         raise ValueError("Unexpected pickle structure")
 
-    # Extract and flatten results
+    # Extract and flatten results — include listener/speaker distributions
+    # for rich agreement visualization in the UI (R% bars, divergent cards)
     csv_data = []
     for index, result in enumerate(tqdm(results, desc="Converting")):
         row = {
@@ -163,6 +164,22 @@ def convert_pk_to_csv(pickle_path: Path,
             'consensuality_scores': json.dumps(result.get('consensuality_scores').to_dict())
                 if isinstance(result.get('consensuality_scores'), pd.Series) else None,
         }
+
+        # Save listener_df: DataFrame (N_reviews × K_sentences) of log-probs
+        # Stored as JSON: {sentence: {R1: logprob, R2: logprob, ...}}
+        listener_df = result.get('listener_df')
+        if listener_df is not None and isinstance(listener_df, pd.DataFrame):
+            row['listener_df'] = listener_df.to_json()
+        else:
+            row['listener_df'] = None
+
+        # Save speaker_df: DataFrame (N_reviews × K_sentences) of log-probs
+        speaker_df = result.get('speaker_df')
+        if speaker_df is not None and isinstance(speaker_df, pd.DataFrame):
+            row['speaker_df'] = speaker_df.to_json()
+        else:
+            row['speaker_df'] = None
+
         csv_data.append(row)
 
     # Save to expected location

pipeline/scored_reviews_builder.py

@@ -23,6 +23,57 @@ BASE_DIR = Config.BASE_DIR
 #     return sentences        
         
         
+def _parse_rsa_distributions(scored_df: pd.DataFrame, review_id: str) -> dict:
+    """
+    Parse listener/speaker DataFrames from the GLIMPSE results CSV.
+
+    Returns dict with:
+      listener: {sentence: {R1: prob, R2: prob, ...}} — normalized probabilities
+      speaker:  {R1: {sentence: prob}, ...} — normalized probabilities
+    Returns empty dict if data not available (backward compat with older CSVs).
+    """
+    import numpy as np
+
+    row = scored_df[scored_df["id"] == review_id].iloc[0]
+
+    listener_json = row.get("listener_df") if "listener_df" in scored_df.columns else None
+    speaker_json = row.get("speaker_df") if "speaker_df" in scored_df.columns else None
+
+    if not listener_json or not speaker_json or pd.isna(listener_json) or pd.isna(speaker_json):
+        return {}
+
+    try:
+        listener_df = pd.read_json(listener_json)
+        speaker_df = pd.read_json(speaker_json)
+    except Exception:
+        return {}
+
+    num_reviews = len(listener_df)
+    review_labels = [f"R{i+1}" for i in range(num_reviews)]
+
+    # Listener: exponentiate log-probs, normalize per column (per sentence)
+    listener_probs = np.exp(listener_df.values)
+    col_sums = listener_probs.sum(axis=0, keepdims=True)
+    col_sums = np.where(col_sums > 0, col_sums, 1.0)
+    listener_probs = listener_probs / col_sums
+    listener = {
+        sent: {review_labels[i]: float(listener_probs[i, j]) for i in range(num_reviews)}
+        for j, sent in enumerate(listener_df.columns)
+    }
+
+    # Speaker: exponentiate log-probs, normalize per row (per review)
+    speaker_probs = np.exp(speaker_df.values)
+    row_sums = speaker_probs.sum(axis=1, keepdims=True)
+    row_sums = np.where(row_sums > 0, row_sums, 1.0)
+    speaker_probs = speaker_probs / row_sums
+    speaker = {
+        review_labels[i]: {sent: float(speaker_probs[i, j]) for j, sent in enumerate(speaker_df.columns)}
+        for i in range(num_reviews)
+    }
+
+    return {"listener": listener, "speaker": speaker}
+
+
 def preprocessed_scores(
         original_csv_path: Path,
         scored_csv_path: Path,
@@ -47,6 +98,9 @@ def preprocessed_scores(
         except Exception as e:
             print(f"Warning: Could not load rebuttals from {raw_data_csv_path}: {e}")
 
+    # Pre-parse RSA distributions per submission (listener/speaker are shared across reviews)
+    rsa_cache = {}
+
     scored_reviews = {}
     submission_review_counters = {}  # Track which review # we're on for each submission
 
@@ -77,6 +131,10 @@ def preprocessed_scores(
             print("Problematic string:", consensuality_scores_str)
             continue  # skip this problematic entry
 
+        # Parse RSA distributions (once per submission)
+        if review_id not in rsa_cache:
+            rsa_cache[review_id] = _parse_rsa_distributions(scored_df, review_id)
+
         # Get polarity scores
         polarity_rows = polarity_df[polarity_df["id"] == review_id]
         polarity_dict = dict(zip(polarity_rows["sentence"], polarity_rows["polarity"]))
@@ -116,7 +174,7 @@ def preprocessed_scores(
             "rebuttal": rebuttal
         })
 
-    return scored_reviews
+    return scored_reviews, rsa_cache
 
 
 def save_all_scored_reviews(
@@ -140,7 +198,7 @@ def save_all_scored_reviews(
             polarity_csv_path = polarity_dir / f"polarity_scored_reviews_{year}.csv"
             topic_csv_path = topic_dir / f"topic_scored_reviews_{year}.csv"
             scored_csv_path = scored_csv_dir / f"GLIMPSE_results_{year}.csv"
-            scored_reviews = preprocessed_scores(
+            scored_reviews, _ = preprocessed_scores(
                 original_csv_path,
                 scored_csv_path,
                 polarity_csv_path,
@@ -213,7 +271,7 @@ def build_dataset(
             raw_data_csv_path = BASE_DIR / "data" / f"all_reviews_{year}.csv"
 
             # Use existing preprocessed_scores function
-            scored_reviews = preprocessed_scores(
+            scored_reviews, rsa_cache = preprocessed_scores(
                 original_csv_path,
                 scored_csv_path,
                 polarity_csv_path,
@@ -253,6 +311,11 @@ def build_dataset(
                     'has_rebuttal': bool(rebuttal_str.strip()) if rebuttal_str else False,
                 }
 
+            # Merge RSA distributions into metadata (listener/speaker per submission)
+            for review_id, rsa_data in rsa_cache.items():
+                if rsa_data and review_id in review_metadata:
+                    review_metadata[review_id]['rsa'] = rsa_data
+
             all_scored_reviews.append({
                 "year": year,
                 "scored_dict": scored_reviews,