mad outlier detection for problematic phases

src/app.py

@@ -19,7 +19,8 @@ def load_model(model_name):
     st.info(f"Loading model '{model_name}'... This may take a moment on the first run.")
     try:
         tokenizer = AutoTokenizer.from_pretrained(model_name, cache_dir=cache_dir, trust_remote_code=True)
-        model = AutoModelForCausalLM.from_pretrained(model_name, cache_dir=cache_dir, trust_remote_code=True, attn_implementation="eager")
+        model = AutoModelForCausalLM.from_pretrained(model_name, cache_dir=cache_dir, trust_remote_code=True,
+                                                     attn_implementation="eager")
         st.success(f"Model '{model_name}' loaded and ready!")
         return tokenizer, model
     except Exception as e:
@@ -64,25 +65,54 @@ def get_analysis_data(text_to_analyze, system_prompt, tokenizer, model):
     return list(zip(tokens, sequence_log_probs)), full_tokens, last_layer_attention, start_index, end_index
 
 
-def find_high_perplexity_phrases(analysis_data, std_dev_threshold=1.5):
-    if not analysis_data: return []
-    log_probs = [lp for _, lp in analysis_data]
-    mean_lp = np.mean(log_probs)
-    std_lp = np.std(log_probs)
-    threshold = mean_lp - std_dev_threshold * std_lp
+def get_outlier_indices(analysis_data, threshold=-3.0):
+    """
+    Identifies the indices of outlier tokens using the Median Absolute Deviation (MAD).
+    A lower log-probability is more surprising, so we look for large negative scores.
+    """
+    if not analysis_data or len(analysis_data) < 5:
+        return np.array([])
+
+    log_probs = np.array([lp for _, lp in analysis_data])
+    median_lp = np.median(log_probs)
+    # Calculate Median Absolute Deviation (MAD)
+    mad = np.median(np.abs(log_probs - median_lp))
+
+    if mad == 0:  # Avoid division by zero if many values are the same
+        return np.array([])
+
+    # Calculate the modified Z-scores (robust against outliers)
+    modified_z_scores = 0.6745 * (log_probs - median_lp) / mad
+
+    # Return indices where the score is below the threshold
+    return np.where(modified_z_scores < threshold)[0]
+
+
+def find_high_perplexity_phrases(analysis_data, outlier_indices):
+    """
+    Groups contiguous outlier tokens into phrases.
+    """
+    if not analysis_data or outlier_indices.size == 0:
+        return []
 
     outlier_phrases = []
     current_phrase = ""
-    for token, log_prob in analysis_data:
+    on_outlier_streak = False
+
+    for i, (token, _) in enumerate(analysis_data):
         display_token = token.replace('Ġ', ' ')
-        if log_prob < threshold:
+        if i in outlier_indices:
             current_phrase += display_token
+            on_outlier_streak = True
         else:
-            if current_phrase:
+            if on_outlier_streak:
                 outlier_phrases.append(current_phrase.strip())
                 current_phrase = ""
-    if current_phrase:
+            on_outlier_streak = False
+
+    if current_phrase:  # Catch a phrase that ends the sentence
         outlier_phrases.append(current_phrase.strip())
+
     return outlier_phrases
 
 
@@ -105,23 +135,39 @@ Explain, step-by-step, why the model found **these specific phrases** surprising
 
 
 def get_color_for_logprob(logprob, min_logprob, max_logprob):
-    if min_logprob >= max_logprob: return "#FFFFFF"
+    if min_logprob >= max_logprob: return "#FFB3B3"  # A default soft red
     normalized = (logprob - min_logprob) / (max_logprob - min_logprob)
-    hue = normalized * 0.4
+    hue = normalized * 0.4  # Scale from Red (0.0) to Greenish-Yellow (0.4)
     rgb = colorsys.hsv_to_rgb(hue, 0.9, 0.95)
     return '#%02x%02x%02x' % (int(rgb[0] * 255), int(rgb[1] * 255), int(rgb[2] * 255))
 
 
-def render_colored_text(analysis_data, min_logprob, max_logprob):
+def render_colored_text(analysis_data, outlier_indices):
+    """
+    Renders text, highlighting only the outlier tokens.
+    The color intensity of outliers is still scaled relative to each other.
+    """
     html_elements = []
-    for token, logprob in analysis_data:
+
+    # For scaling the color of the outliers themselves
+    outlier_log_probs = [analysis_data[i][1] for i in outlier_indices]
+    min_lp = min(outlier_log_probs) if outlier_log_probs else 0
+    max_lp = max(outlier_log_probs) if outlier_log_probs else 0
+
+    for i, (token, logprob) in enumerate(analysis_data):
         perplexity = math.exp(-logprob) if logprob != 0 else 1
         display_token = token.replace('Ġ', ' ')
-        color = get_color_for_logprob(logprob, min_logprob, max_logprob)
         tooltip = f"Perplexity: {perplexity:.2f}"
-        html_elements.append(
-            f'<span style="background-color: {color}; padding: 2px 1px; margin: 0px; border-radius: 3px;" title="{tooltip}">{display_token}</span>'
-        )
+
+        if i in outlier_indices:
+            color = get_color_for_logprob(logprob, min_lp, max_lp)
+            html_elements.append(
+                f'<span style="background-color: {color}; padding: 2px 1px; margin: 0px; border-radius: 3px;" title="{tooltip}">{display_token}</span>'
+            )
+        else:
+            # Not an outlier, render with no background color
+            html_elements.append(f'<span title="{tooltip}">{display_token}</span>')
+
     return "".join(html_elements)
 
 
@@ -208,8 +254,7 @@ def render_interactive_text(tokens, attention_matrix, start_index, threshold):
 st.set_page_config(layout="wide", page_title="QCD Text Validator & Inspector", page_icon="🔬")
 st.title("QCD Text Validator & Inspector")
 
-MODEL_NAME = "Qwen/Qwen2.5-3B-Instruct"
-# SYSTEM_PROMPT = "You are a particle physicist specializing in Quantum Chromodynamics (QCD)..."
+MODEL_NAME = "Qwen/Qwen1.5-1.8B-Chat"
 SYSTEM_PROMPT = """
 You are an expert peer reviewer for a top-tier physics journal, specializing in the theory of the strong interaction (Quantum Chromodynamics). Your task is to rigorously evaluate statements for their strict adherence to the established principles of the Standard Model.
 
@@ -220,11 +265,15 @@ Do not tolerate simplifications, analogies, or pop-science descriptions that are
 
 try:
     tokenizer, model = load_model(MODEL_NAME)
-    default_text = "In QCD, asymptotic freedom incorrectly states that the strong force between quarks grows stronger at high energies."
+    default_text = "In QCD, asymptotic freedom incorrectly states that the strong force between quarks grows stronger at high energies, while in reality it gets weaker."
     text_to_analyze = st.text_area("Enter Text to Analyze:", value=default_text, height=150)
 
     if st.button("Analyze Text", key="analyze_button", type="primary"):
-        for key in list(st.session_state.keys()): del st.session_state[key]
+        # Clear previous analysis from session state
+        for key in list(st.session_state.keys()):
+            if key not in ['tokenizer', 'model']:  # Don't clear the loaded model
+                del st.session_state[key]
+
         if text_to_analyze:
             with st.spinner("Performing analysis and calculating attention..."):
                 analysis_data, full_tokens, attention_matrix, start_idx, end_idx = get_analysis_data(text_to_analyze,
@@ -236,11 +285,19 @@ try:
                 st.session_state.attention_matrix = attention_matrix
                 st.session_state.start_index = start_idx
                 st.session_state.end_index = end_idx
-                st.session_state.suspicious_phrases = find_high_perplexity_phrases(analysis_data)
+
+                # --- MODIFIED LOGIC ---
+                # 1. Get outlier indices first
+                outlier_indices = get_outlier_indices(analysis_data)
+                st.session_state.outlier_indices = outlier_indices
+
+                # 2. Find phrases based on these indices
+                st.session_state.suspicious_phrases = find_high_perplexity_phrases(analysis_data, outlier_indices)
+
                 st.session_state.original_text = text_to_analyze
                 st.session_state.analysis_complete = True
             else:
-                st.warning("Analysis could not be completed.")
+                st.warning("Analysis could not be completed. The input text might be too short or unusual.")
         else:
             st.warning("Please enter some text to analyze.")
 
@@ -249,10 +306,11 @@ try:
 
         # Perplexity Analysis Section
         st.subheader("📝 Perplexity Analysis")
-        st.markdown("Color indicates model surprise (Red = High Surprise, Green = Low Surprise).")
-        min_lp = min([lp for _, lp in st.session_state.analysis_data], default=0)
-        max_lp = max([lp for _, lp in st.session_state.analysis_data], default=0)
-        colored_text_html = render_colored_text(st.session_state.analysis_data, min_lp, max_lp)
+        st.markdown("Color indicates model surprise (**outliers only**). A lack of color means the text is plausible.")
+
+        # --- MODIFIED LOGIC ---
+        # 3. Pass indices to the rendering function
+        colored_text_html = render_colored_text(st.session_state.analysis_data, st.session_state.outlier_indices)
         st.markdown(colored_text_html, unsafe_allow_html=True)
         st.markdown("---")
 
@@ -266,8 +324,10 @@ try:
         user_attention_matrix = st.session_state.attention_matrix
 
         max_attention = float(np.max(user_attention_matrix)) if user_attention_matrix.size > 0 else 0.1
+        # Set a sensible default value for the slider
+        default_slider_val = min(0.1, max_attention) if max_attention > 0 else 0.1
         attention_threshold = st.slider("Attention Threshold for Highlighting", min_value=0.0, max_value=max_attention,
-                                        value=min(0.1, max_attention), step=0.01, format="%.2f")
+                                        value=default_slider_val, step=0.01, format="%.2f")
 
         # Render the new interactive text component
         interactive_html = render_interactive_text(user_tokens, user_attention_matrix, start, attention_threshold)
@@ -285,7 +345,7 @@ try:
                                                                               st.session_state.suspicious_phrases,
                                                                               tokenizer, model)
         else:
-            st.info("No specific high-perplexity phrases were found.")
+            st.info("✅ No statistically significant high-perplexity phrases were found.")
 
         if 'deep_dive_result' in st.session_state:
             st.subheader("🧠 Focused Deep Dive Analysis")
@@ -293,3 +353,4 @@ try:
 
 except Exception as e:
     st.error(f"A critical error occurred: {e}")
+    st.exception(e)  # Provides a full traceback in the terminal for debugging