Update src/app.py

supabase integration, some minor modifications + qwen2.5:3b intstr.

src/app.py

@@ -6,13 +6,46 @@ import colorsys
 import math
 import os
 import streamlit.components.v1 as components
+from supabase_py import create_client, Client
 
+# --- Supabase & Model Constants ---
+MODEL_NAME = "Qwen/Qwen2.5-3B-Instruct"
+SYSTEM_PROMPT = """You are a precision analysis tool for physics statements. Your task is to identify the single, specific word that makes a statement factually incorrect according to the Standard Model of particle physics, particularly QCD.
 
-# --- Core Functions (Cached) ---
+Follow these rules strictly:
+1.  **Analyze at the word level:** Scrutinize each word. If a statement is mostly correct but is invalidated by one word, you must identify that specific word.
+2.  **Handle Correct Statements:** If the statement is entirely, unambiguously correct, the incorrect word is "None". Do not flag typos if the meaning is clear.
+3.  **Prioritize the Core Error:** If a statement contains multiple errors, identify the word that introduces the most fundamental factual error."""
+
+
+# --- Database Functions ---
+def init_connection():
+    """Initializes connection to Supabase using Streamlit secrets."""
+    try:
+        url = st.secrets["SUPABASE_URL"]
+        key = st.secrets["SUPABASE_KEY"]
+        return create_client(url, key)
+    except Exception as e:
+        # Gracefully handle missing secrets
+        st.error(f"Failed to connect to Supabase. Check your secrets. Error: {e}")
+        return None
+
+
+def insert_query(supabase_client: Client, query_text: str):
+    """Inserts a new query into the Supabase database."""
+    if not supabase_client:
+        return  # Don't proceed if the connection failed
+    try:
+        # Assumes a table named 'queries' with a column 'query_text'
+        supabase_client.table("queries").insert({"query_text": query_text}).execute()
+    except Exception as e:
+        st.error(f"Database error: {e}")
+
+
+# --- Core ML Functions (Cached) ---
 @st.cache_resource
 def load_model(model_name):
     """Loads the specified model and tokenizer from Hugging Face."""
-    # This function now only loads the model and tokenizer without displaying status here.
     cache_dir = '/tmp/hf_cache'
     os.environ['HF_HOME'] = cache_dir
     os.environ['TRANSFORMERS_CACHE'] = cache_dir
@@ -23,7 +56,6 @@ def load_model(model_name):
                                                      attn_implementation="eager")
         return tokenizer, model
     except Exception as e:
-        # We will handle the error display in the main app body
         st.session_state.model_error = e
         return None, None
 
@@ -65,21 +97,15 @@ 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 get_outlier_indices(analysis_data, threshold=-1.5):
-    """
-    Identifies outlier token indices using Median Absolute Deviation (MAD).
-    The threshold is now more sensitive by default.
-    """
+def get_outlier_indices(analysis_data, threshold=-2.5):
+    """Identifies outlier token indices using Median Absolute Deviation (MAD)."""
     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)
     mad = np.median(np.abs(log_probs - median_lp))
-
     if mad == 0:
         return np.array([])
-
     modified_z_scores = 0.6745 * (log_probs - median_lp) / mad
     return np.where(modified_z_scores < threshold)[0]
 
@@ -88,11 +114,11 @@ 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 i, (token, _) in enumerate(analysis_data):
-        display_token = token.replace('Ġ', ' ')
+        # Corrected: Use ' ' (U+2581) which Qwen uses for spaces
+        display_token = token.replace(' ', ' ')
         if i in outlier_indices:
             current_phrase += display_token
         else:
@@ -105,6 +131,7 @@ def find_high_perplexity_phrases(analysis_data, outlier_indices):
 
 
 def run_focused_deep_dive(original_text, phrases, tokenizer, model):
+    """Generates a deep-dive analysis and cleans the model's output."""
     cot_system_prompt = "You are a meticulous and rigorous particle physicist..."
     phrases_str = "\n".join([f"- \"{p}\"" for p in phrases])
     cot_user_prompt = f"""I have analyzed the following statement:
@@ -119,101 +146,82 @@ Explain, step-by-step, why the model found **these specific phrases** surprising
     with torch.no_grad():
         outputs = model.generate(**inputs, max_new_tokens=512, do_sample=True, temperature=0.3, top_p=0.95)
     response_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
-    return response_text.split("assistant\n")[-1]
+    # Clean potential artifacts from model output
+    result = response_text.split("assistant\n")[-1]
+    cleaned_result = result.replace('\nC', '\n').lstrip('C').strip()
+    return cleaned_result
 
 
 def get_color(logprob, min_lp, max_lp, scheme='green_yellow'):
     """Generates a color based on the specified color scheme."""
     if min_lp >= max_lp:
-        hue = 0.33 if scheme == 'green_yellow' else 0.0  # Default to green or red
+        hue = 0.33 if scheme == 'green_yellow' else 0.0
     else:
         normalized = (logprob - min_lp) / (max_lp - min_lp)
         if scheme == 'green_yellow':
-            # Scale from Yellow (0.17) to Green (0.33)
-            # Higher logprob (less surprise) = greener
             hue = 0.17 + normalized * (0.33 - 0.17)
-        else:  # 'yellow_red'
-            # Scale from Red (0.0) to Yellow (0.17)
-            # Higher logprob (less surprise) = more yellow
+        else:
             hue = 0.0 + normalized * 0.17
-
     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, outlier_indices):
-    """
-    Renders text with conditional color schemes.
-    - No outliers: Green-to-yellow scale for all text.
-    - With outliers: Green-to-yellow for normal text, Yellow-to-red for outliers.
-    """
+    """Renders text with conditional color schemes."""
     html_elements = []
     log_probs = np.array([lp for _, lp in analysis_data])
 
     if not outlier_indices.any():
-        # No outliers: Use a single green-yellow scale for all tokens
         min_lp, max_lp = (log_probs.min(), log_probs.max()) if log_probs.size > 0 else (0, 0)
         for token, logprob in analysis_data:
             color = get_color(logprob, min_lp, max_lp, 'green_yellow')
-            display_token = token.replace('Ġ', ' ')
+            display_token = token.replace(' ', ' ')
             perplexity = math.exp(-logprob) if logprob != 0 else 1
             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>')
     else:
-        # Outliers exist: Use two different color scales
         non_outlier_mask = np.ones(len(log_probs), dtype=bool)
         non_outlier_mask[outlier_indices] = False
-
         non_outlier_lps = log_probs[non_outlier_mask]
         outlier_lps = log_probs[outlier_indices]
-
         min_non_outlier, max_non_outlier = (
         non_outlier_lps.min(), non_outlier_lps.max()) if non_outlier_lps.size > 0 else (0, 0)
         min_outlier, max_outlier = (outlier_lps.min(), outlier_lps.max()) if outlier_lps.size > 0 else (0, 0)
 
         for i, (token, logprob) in enumerate(analysis_data):
-            display_token = token.replace('Ġ', ' ')
+            display_token = token.replace(' ', ' ')
             perplexity = math.exp(-logprob) if logprob != 0 else 1
             tooltip = f"Perplexity: {perplexity:.2f}"
-            if i in outlier_indices:
-                color = get_color(logprob, min_outlier, max_outlier, 'yellow_red')
-            else:
-                color = get_color(logprob, min_non_outlier, max_non_outlier, 'green_yellow')
+            color = get_color(logprob, min_outlier, max_outlier, 'yellow_red') if i in outlier_indices else get_color(
+                logprob, min_non_outlier, max_non_outlier, 'green_yellow')
             html_elements.append(
                 f'<span style="background-color: {color}; padding: 2px 1px; margin: 0px; border-radius: 3px;" title="{tooltip}">{display_token}</span>')
-
     return "".join(html_elements)
 
 
 def render_interactive_text(tokens, attention_matrix, start_index, threshold):
     """Generates interactive HTML to highlight attention targets on hover."""
     css = """<style>.interactive-text-container{line-height:2.0;font-size:1.1em}.token{cursor:pointer;padding:2px 4px;border-radius:4px;transition:background-color .2s ease-in-out}.source-highlight{background-color:#ffd700;color:#000}.target-highlight{background-color:#1e90ff;color:#fff}</style>"""
+    js = """<script>const allTokens=document.querySelectorAll('.token');function highlightTargets(e,t){clearHighlights();const n=document.getElementById(e);n&&n.classList.add('source-highlight'),t.forEach(e=>{const t=document.getElementById(e);t&&t.classList.add('target-highlight')})}function clearHighlights(){allTokens.forEach(e=>{e.classList.remove('source-highlight'),e.classList.remove('target-highlight')})}</script>"""
     token_spans = []
     for i, token_text in enumerate(tokens):
         original_i = start_index + i
-        display_text = token_text.replace('Ġ', ' ')
-        targets = []
-        for j, _ in enumerate(tokens):
-            if i == j: continue
-            original_j = start_index + j
-            score = max(attention_matrix[original_i, original_j], attention_matrix[original_j, original_i])
-            if score > threshold: targets.append(f"'token-{original_j}'")
-        targets_str = ",".join(targets)
-        token_id = f"token-{original_i}"
-        span = f'<span class="token" id="{token_id}" onmouseover="highlightTargets(\'{token_id}\',[{targets_str}])" onmouseout="clearHighlights()">{display_text}</span>'
+        display_text = token_text.replace(' ', ' ')
+        targets = [f"'token-{start_index + j}'" for j, _ in enumerate(tokens) if
+                   i != j and max(attention_matrix[original_i, start_index + j],
+                                  attention_matrix[start_index + j, original_i]) > threshold]
+        span = f'<span class="token" id="token-{original_i}" onmouseover="highlightTargets(\'token-{original_i}\',[{",".join(targets)}])" onmouseout="clearHighlights()">{display_text}</span>'
         token_spans.append(span)
-    js = """<script>const allTokens=document.querySelectorAll('.token');function highlightTargets(e,t){clearHighlights();const n=document.getElementById(e);n&&n.classList.add('source-highlight'),t.forEach(e=>{const t=document.getElementById(e);t&&t.classList.add('target-highlight')})}function clearHighlights(){allTokens.forEach(e=>{e.classList.remove('source-highlight'),e.classList.remove('target-highlight')})}</script>"""
     html_body = f'<div class="interactive-text-container">{"".join(token_spans)}</div>'
     return f"<html><head>{css}</head><body>{html_body}{js}</body></html>"
 
 
 # --- Streamlit App ---
 st.set_page_config(layout="wide", page_title="QCD Text Validator & Inspector", page_icon="🔬")
-st.title("QCD Text Validator & Inspector")
 
-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. Your analysis must be uncompromising. Treat any statement that contradicts or misrepresents core QCD concepts—such as asymptotic freedom (the weakening of the strong force at high energies), color confinement, the non-Abelian nature of SU(3) gauge theory, or the role of gluons—as a flaggable, high-perplexity anomaly. Do not tolerate simplifications, analogies, or pop-science descriptions that are technically incorrect. Your sole function is to validate the factual accuracy of the physics."""
+# Initialize Supabase connection
+supabase = init_connection()
 
 # Load model and tokenizer, keeping the UI clean
 if 'model' not in st.session_state:
@@ -224,32 +232,35 @@ if 'model' not in st.session_state:
         st.session_state.tokenizer, st.session_state.model = tokenizer, model
         st.session_state.model_status = f"✅ Model '{MODEL_NAME}' loaded successfully."
     else:
-        st.session_state.model_status = f"❌ Error loading model: {st.session_state.model_error}"
+        st.session_state.model_status = f"❌ Error loading model: {st.session_state.get('model_error', 'Unknown error')}"
 
 tokenizer, model = st.session_state.tokenizer, st.session_state.model
 
 if model:
-    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)
+    st.title("Physics Statement Validator")
+    default_text = "The running of the strong coupling of QCD increases with the energy scale."
+    text_to_analyze = st.text_area("Enter a physics statement to analyze:", value=default_text, height=100)
 
-    if st.button("Analyze Text", key="analyze_button", type="primary"):
+    if st.button("Analyze Statement", key="analyze_button", type="primary"):
+        # Clear previous analysis from session state
         for key in list(st.session_state.keys()):
             if key not in ['tokenizer', 'model', 'model_status']:
                 del st.session_state[key]
+
         if text_to_analyze:
-            with st.spinner("Performing analysis and calculating attention..."):
+            # Insert the query into the Supabase database
+            insert_query(supabase, text_to_analyze)
+
+            with st.spinner("Analyzing statement..."):
                 analysis_data, full_tokens, attention_matrix, start_idx, end_idx = get_analysis_data(text_to_analyze,
                                                                                                      SYSTEM_PROMPT,
                                                                                                      tokenizer, model)
+
             if analysis_data:
                 st.session_state.analysis_data = analysis_data
-                st.session_state.full_tokens = full_tokens
-                st.session_state.attention_matrix = attention_matrix
-                st.session_state.start_index = start_idx
-                st.session_state.end_index = end_idx
-                outlier_indices = get_outlier_indices(analysis_data)
-                st.session_state.outlier_indices = outlier_indices
-                st.session_state.suspicious_phrases = find_high_perplexity_phrases(analysis_data, outlier_indices)
+                st.session_state.outlier_indices = get_outlier_indices(analysis_data)
+                st.session_state.suspicious_phrases = find_high_perplexity_phrases(analysis_data,
+                                                                                   st.session_state.outlier_indices)
                 st.session_state.original_text = text_to_analyze
                 st.session_state.analysis_complete = True
             else:
@@ -259,38 +270,42 @@ if model:
 
     if st.session_state.get('analysis_complete', False):
         st.markdown("---")
-        st.subheader("📝 Perplexity Analysis")
-        st.markdown(
-            "Color indicates model surprise. Green is predictable, yellow is less so. Red highlights statistical outliers.")
-        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("---")
-
-        st.subheader("💡 Interactive Attention")
-        st.markdown("Hover over any word to highlight other words it pays strong attention to.")
-        start, end = st.session_state.start_index, st.session_state.end_index
-        user_tokens, user_attention_matrix = st.session_state.full_tokens[start:end], st.session_state.attention_matrix
-        max_attention = float(np.max(user_attention_matrix)) if user_attention_matrix.size > 0 else 0.1
-        default_slider_val = min(0.1, max_attention) if max_attention > 0 else 0.1
-        attention_threshold = st.slider("Attention Threshold", 0.0, max_attention, default_slider_val, 0.01, "%.2f")
-        interactive_html = render_interactive_text(user_tokens, user_attention_matrix, start, attention_threshold)
-        components.html(interactive_html, height=200, scrolling=True)
-        st.markdown("---")
+        st.subheader("📝 Analysis Result")
 
         if st.session_state.suspicious_phrases:
-            st.warning("High-perplexity phrases identified:")
-            for phrase in st.session_state.suspicious_phrases: st.markdown(f"- *{phrase}*")
-            if st.button("Run Deep Dive on Suspicious Phrases", key="deep_dive_button"):
-                with st.spinner("Performing focused deep dive..."):
-                    st.session_state.deep_dive_result = run_focused_deep_dive(st.session_state.original_text,
-                                                                              st.session_state.suspicious_phrases,
-                                                                              tokenizer, model)
+            st.warning("The model identified the following word(s) as the most likely error:")
+            for phrase in st.session_state.suspicious_phrases:
+                st.markdown(f"> **{phrase}**")
         else:
-            st.info("✅ No statistically significant high-perplexity phrases were found.")
-
-        if 'deep_dive_result' in st.session_state:
-            st.subheader("🧠 Focused Deep Dive Analysis")
-            st.markdown(st.session_state.deep_dive_result)
+            st.success("✅ The model did not find any statistically significant errors in the statement.")
+
+        with st.expander("Show Detailed Perplexity and Attention Analysis"):
+            st.markdown("#### Perplexity Analysis")
+            st.markdown(
+                "Color indicates model surprise. Green is predictable, yellow is less so. Red highlights statistical outliers.")
+            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("---")
+
+            st.markdown("#### Interactive Attention")
+            st.markdown("Hover over any word to highlight other words it pays strong attention to.")
+            st.session_state.full_tokens = st.session_state.get('full_tokens', [])
+            st.session_state.attention_matrix = st.session_state.get('attention_matrix', np.array([]))
+            st.session_state.start_index = st.session_state.get('start_index', -1)
+            st.session_state.end_index = st.session_state.get('end_index', -1)
+
+            start, end = st.session_state.start_index, st.session_state.end_index
+            if start != -1 and end != -1 and st.session_state.attention_matrix.size > 0:
+                user_tokens = st.session_state.full_tokens[start:end]
+                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
+                default_slider_val = min(0.1, max_attention) if max_attention > 0 else 0.1
+                attention_threshold = st.slider("Attention Threshold", 0.0, max_attention, default_slider_val, 0.01,
+                                                "%.2f")
+                interactive_html = render_interactive_text(user_tokens, user_attention_matrix, start,
+                                                           attention_threshold)
+                components.html(interactive_html, height=200, scrolling=True)
 
 # Display model status at the bottom
 with st.expander("System Status", expanded=False):