updated algorithm for llm/gram2vec feature showing

app.py

@@ -462,13 +462,6 @@ def app(share=False):
                     ">
                         Gram2Vec Features prominent in the zoomed-in region
                     </div>
-                    <div style="
-                        font-size: 0.9em;
-                        color: #666;
-                        margin-bottom: 1em;
-                    ">
-                        Features shown with normalized z-scores
-                    </div>
                     """)
                 gram2vec_rb    = gr.Radio(choices=[], label="Gram2Vec features for this zoomed-in region")#, label="Top-10 Gram2Vec Features most likely to occur in Mystery Author", info="Most prominent Gram2Vec features in the mystery text")
                 gram2vec_state = gr.State()
@@ -562,7 +555,7 @@ def app(share=False):
 
         axis_ranges.change(
             fn=handle_zoom_with_retries, 
-            inputs=[axis_ranges, bg_proj_state, bg_lbls_state, bg_authors_df, task_authors_embeddings_df], 
+            inputs=[axis_ranges, bg_proj_state, bg_lbls_state, bg_authors_df, task_authors_embeddings_df, predicted_author], 
             outputs=[features_rb, gram2vec_rb , llm_style_feats_analysis, feature_list_state, visible_zoomed_authors]
         )
 

utils/gram2vec_feat_utils.py

@@ -284,6 +284,54 @@ def create_html(texts, llm_spans_list, gram_spans_list, selected_feature_llm, se
         # print(i, label, txt[:30])
         label = get_label(label, predicted_author, ground_truth_author,  i) if background else get_label(label, predicted_author, ground_truth_author)
         combined = highlight_both_spans(txt, llm_spans_list[i], gram_spans_list[i])
+        
+        # Count spans for display
+        llm_span_count = len(llm_spans_list[i])
+        gram_span_count = len(gram_spans_list[i])
+        
+        # Build span count display
+        span_count_info = ""
+        if selected_feature_llm != "None" or selected_feature_g2v != "None":
+            span_count_info = """
+            <div style="
+                background: #f5f5f5;
+                border: 1px solid #ddd;
+                border-radius: 4px;
+                padding: 8px;
+                margin-bottom: 8px;
+                font-size: 0.95em;
+                display: flex;
+                gap: 1em;
+            ">
+            """
+            if selected_feature_llm != "None":
+                span_count_info += f"""
+                <div style="flex: 1;">
+                    <strong>LLM Feature Spans:</strong>
+                    <span style="
+                        background: #FFEB3B;
+                        padding: 2px 8px;
+                        border-radius: 3px;
+                        margin-left: 4px;
+                        font-weight: bold;
+                    ">{llm_span_count}</span>
+                </div>
+                """
+            if selected_feature_g2v != "None":
+                span_count_info += f"""
+                <div style="flex: 1;">
+                    <strong>G2V Feature Spans:</strong>
+                    <span style="
+                        background: #5CB3FF;
+                        padding: 2px 8px;
+                        border-radius: 3px;
+                        margin-left: 4px;
+                        font-weight: bold;
+                    ">{gram_span_count}</span>
+                </div>
+                """
+            span_count_info += "</div>"
+        
         notice = ""
         if selected_feature_llm == "None":
             notice += f"""
@@ -317,6 +365,7 @@ def create_html(texts, llm_spans_list, gram_spans_list, selected_feature_llm, se
             """
         html.append(f"""
           <h3>{label}</h3>
+          {span_count_info}
           {notice}
           <div style="border:1px solid #ccc; padding:8px; margin-bottom:1em;">
             {combined}

utils/interp_space_utils.py

@@ -574,10 +574,12 @@ def compute_clusters_style_representation_3(
     max_num_documents_per_author=10,
     max_num_authors=10,
     max_authors_for_span_extraction=4,
-    top_k: int = 10
+    top_k: int = 10,
+    predicted_author: int = None
     ):
 
     print(f"Computing style representation for visible clusters: {len(cluster_ids)}")
+    print(f"Predicted author: {predicted_author}")
     # STEP 1: Identify features on max_num_authors's max_num_documents_per_author number of documents
     background_corpus_df['fullText'] = background_corpus_df['fullText'].map(lambda x: '\n\n'.join(x[:max_num_documents_per_author]) if isinstance(x, list) else x)
     background_corpus_df_feat_id = background_corpus_df[background_corpus_df[cluster_label_clm_name].isin(cluster_ids)]
@@ -599,47 +601,30 @@ def compute_clusters_style_representation_3(
     
     # Filter-in only task authors that are part of the current selection
     task_author_names = {'Mystery author', 'Candidate Author 1', 'Candidate Author 2', 'Candidate Author 3'}
-    #filtered_task_authors = {author: feat_map for author, feat_map in spans_by_author.items() if author in task_author_names.intersection(set(cluster_ids))}
-
-    # Build per-author sets of features that have at least one span
-    # author_present_feature_sets = [
-    #     {feature for feature, spans in feature_map.items() if spans and len(spans) > 0}
-    #     for _, feature_map in filtered_task_authors.items()
-    # ]
-
-    # print(filtered_task_authors.keys(), author_present_feature_sets)
     
+    # Define mystery and predicted author names
+    mystery_author = 'Mystery author'
+    predicted_author_name = f'Candidate Author {predicted_author + 1}' if predicted_author is not None else None
     
-    # if len(author_present_feature_sets) > 0: # we have more than one task author
-    #     coverage_counter = Counter()
-    #     for present_set in author_present_feature_sets:
-    #         coverage_counter.update(present_set)
-
-    #     # Keep features present in at least `min_authors_required` authors
-    #     eligible_features = [feat for feat, cnt in coverage_counter.items() if cnt >= len(author_present_feature_sets)]
-
-    #     # Preserve original LLM feature ordering as a secondary key where possible
-    #     feature_original_index = {feat: idx for idx, feat in enumerate(features)} if features else {}
-
-    #     selected_features_ranked = sorted(
-    #         eligible_features,
-    #         key=lambda f: (-coverage_counter[f], feature_original_index.get(f, 10**9))
-    #     )[:int(top_k)]
-    # else:
-    #     selected_features_ranked = features
-
-
+    # Compute feature importance based on Mystery + Predicted author vs. other candidates
     feature_importance = {f : 0 for f in features}
     for author, feature_map in spans_by_author.items():
         if author in task_author_names.intersection(set(cluster_ids)):
             for feature, spans in feature_map.items():
                 if spans:
-                    feature_importance[feature] += len(spans)
+                    # Add span count if Mystery or Predicted author, subtract if other candidate
+                    if author == mystery_author or (predicted_author is not None and author == predicted_author_name):
+                        feature_importance[feature] += len(spans)
+                    else:
+                        # Other candidates - subtract their span counts
+                        feature_importance[feature] -= len(spans)
         else:
+            # Background authors - subtract their span counts
             for feature, spans in feature_map.items():
                 if spans:
                     feature_importance[feature] -= len(spans)
-    # print(feature_importance)
+    
+    print(f"Feature importance scores: {feature_importance}")
     selected_features_ranked = sorted(feature_importance, key=lambda f: -feature_importance[f])[:int(top_k)]
 
     #print('filtered set of features (min coverage', len(author_present_feature_sets), '): ', selected_features_ranked)
@@ -656,8 +641,10 @@ def compute_clusters_g2v_representation(
     features_clm_name: str,
     top_n: int = 10,
     max_candidates_for_span_sorting: int = 50,
+    predicted_author: int = None
 ) -> List[tuple]:  # Changed return type to List[tuple] to include scores
 
+    print(f"[INFO] Computing G2V representation with predicted_author: {predicted_author}")
     # 1) Identify selected authors in the zoom region
     selected_mask = background_corpus_df['authorID'].isin(author_ids).to_numpy()
 
@@ -705,15 +692,17 @@ def compute_clusters_g2v_representation(
     # Get task author data
     task_authors_df = background_corpus_df[background_corpus_df['authorID'].isin(task_authors_in_selection)]
     
-    # Count spans for each feature across task authors
-    feature_span_counts = {}
+    # Define mystery and predicted author names
+    mystery_author = 'Mystery author'
+    predicted_author_name = f'Candidate Author {predicted_author + 1}' if predicted_author is not None else None
+    
+    # Count spans for each feature: +1 for Mystery/Predicted, -1 for other candidates
+    feature_span_scores = {}
     for feat_shorthand, z_score in candidate_features:
-        span_count = 0
-        
-        # Convert shorthand to human-readable for display (if needed)
-        # Note: features in gram2vec dict are in shorthand format like "pos_unigrams:ADJ"
+        span_score = 0
         
         for _, author_row in task_authors_df.iterrows():
+            author_name = author_row['authorID']
             author_text = author_row['fullText']
             if isinstance(author_text, list):
                 author_text = '\n\n'.join(author_text)
@@ -721,20 +710,27 @@ def compute_clusters_g2v_representation(
             try:
                 # find_feature_spans expects shorthand format like "pos_unigrams:ADJ"
                 spans = find_feature_spans(author_text, feat_shorthand)
-                span_count += len(spans)
+                span_count = len(spans)
+                
+                # Add span count if Mystery or Predicted author, subtract if other candidate
+                if author_name == mystery_author or (predicted_author is not None and author_name == predicted_author_name):
+                    span_score += span_count
+                else:
+                    # Other candidates - subtract their span counts
+                    span_score -= span_count
             except Exception as e:
                 # If span extraction fails, continue with 0 spans for this author
                 pass
         
-        feature_span_counts[feat_shorthand] = span_count
+        feature_span_scores[feat_shorthand] = span_score
     
-    # 8) Sort features by span frequency, then by z-score as tiebreaker
+    # 8) Sort features by span score (Mystery+Predicted vs Others), then by z-score as tiebreaker
     sorted_by_spans = sorted(
         candidate_features,
-        key=lambda x: (-feature_span_counts.get(x[0], 0), -x[1])
+        key=lambda x: (-feature_span_scores.get(x[0], 0), -x[1])
     )
     
-    # print(f"[INFO] Sorted gram2vec features by span frequency: {[(f, feature_span_counts.get(f, 0), z) for f, z in sorted_by_spans[:top_n]]}")
+    print(f"[INFO] Top 5 gram2vec features by span score: {[(f, feature_span_scores.get(f, 0), z) for f, z in sorted_by_spans[:5]]}")
     
     return sorted_by_spans[:top_n]
 

utils/visualizations.py

@@ -204,11 +204,11 @@ def load_interp_space(cfg):
 # Function to process G2V features and create display choices
 def format_g2v_features_for_display(g2v_features_with_scores):
     """
-    Convert G2V features with z-scores into display format for Gradio radio buttons.
+    Convert G2V features into display format for Gradio radio buttons.
     
     Args:
         g2v_features_with_scores: List of tuples like:
-            [('None', None), ('Feature Name', z_score), ...]
+            [('None', None), ('Feature Name', score), ...]
     
     Returns:
         tuple: (display_choices, original_values)
@@ -218,22 +218,15 @@ def format_g2v_features_for_display(g2v_features_with_scores):
     
     for item in g2v_features_with_scores:
         if len(item) == 2:
-            feature_name, z_score = item
+            feature_name, score = item
             
             # Handle None case
-            if feature_name == "None" or z_score is None:
+            if feature_name == "None" or score is None:
                 display_choices.append("None")
                 original_values.append("None")
             else:
-                # Convert numpy float to regular float if needed
-                if hasattr(z_score, 'item'):
-                    z_score = float(z_score.item())
-                else:
-                    z_score = float(z_score)
-                
-                # Create display string with z-score
-                display_string = f"{feature_name} | [Z={z_score:.2f}]"
-                display_choices.append(display_string)
+                # Just show the feature name without scores
+                display_choices.append(feature_name)
                 original_values.append(feature_name)
         else:
             # Handle unexpected format
@@ -243,14 +236,17 @@ def format_g2v_features_for_display(g2v_features_with_scores):
     return display_choices, original_values
 
 #function to handle zoom events
-def handle_zoom(event_json, bg_proj, bg_lbls, clustered_authors_df, task_authors_df):
+def handle_zoom(event_json, bg_proj, bg_lbls, clustered_authors_df, task_authors_df, predicted_author=None):
     """
     event_json         – stringified JSON from JS listener
     bg_proj            – (N,2) numpy array with 2D coordinates
     bg_lbls            – list of N author IDs
     clustered_authors_df – pd.DataFrame containing authorID and final_attribute_name
+    task_authors_df    – pd.DataFrame containing task authors
+    predicted_author   – index of predicted author (0, 1, or 2)
     """
     print("[INFO] Handling zoom event")
+    print(f"[INFO] Predicted author: {predicted_author}")
 
     if not event_json:
         return gr.update(value=""), gr.update(value=""), None, None, None
@@ -280,6 +276,7 @@ def handle_zoom(event_json, bg_proj, bg_lbls, clustered_authors_df, task_authors
         background_corpus_df=merged_authors_df,
         cluster_ids=visible_authors,
         cluster_label_clm_name='authorID',
+        predicted_author=predicted_author
     )
 
     llm_feats = ['None'] + style_analysis_response['features']
@@ -292,7 +289,8 @@ def handle_zoom(event_json, bg_proj, bg_lbls, clustered_authors_df, task_authors
         author_ids=visible_authors,
         other_author_ids=[],
         features_clm_name='g2v_vector',
-        top_n=50
+        top_n=50,
+        predicted_author=predicted_author
     )
 
     # ── Span-existence filter on task authors in the zoom ───────────────────
@@ -357,19 +355,20 @@ def handle_zoom(event_json, bg_proj, bg_lbls, clustered_authors_df, task_authors
     )
     # return gr.update(value="\n".join(llm_feats).join("\n").join(g2v_feats)), llm_feats, g2v_feats
 
-def handle_zoom_with_retries(event_json, bg_proj, bg_lbls, clustered_authors_df, task_authors_df):
+def handle_zoom_with_retries(event_json, bg_proj, bg_lbls, clustered_authors_df, task_authors_df, predicted_author=None):
     """
     event_json         – stringified JSON from JS listener
     bg_proj            – (N,2) numpy array with 2D coordinates
     bg_lbls            – list of N author IDs
     clustered_authors_df – pd.DataFrame containing authorID and final_attribute_name
     task_authors_df   – pd.DataFrame containing authorID and final_attribute_name
+    predicted_author  – index of predicted author (0, 1, or 2)
     """
     print("[INFO] Handling zoom event with retries")
 
     for attempt in range(3):
         try:
-            return handle_zoom(event_json, bg_proj, bg_lbls, clustered_authors_df, task_authors_df)
+            return handle_zoom(event_json, bg_proj, bg_lbls, clustered_authors_df, task_authors_df, predicted_author)
         except Exception as e:
             print(f"[ERROR] Attempt {attempt + 1} failed: {e}")
             if attempt < 2: