Update app.py

app.py

@@ -1,240 +1,63 @@
-'''import gradio as gr
-import os
-from inference import get_evo_response, get_gpt_response
-from logger import log_feedback
-import csv
+import gradio as gr
+from inference import evo_chat_predict
 import subprocess
 
-# Helper to load Hall of Fame
-def load_hall_of_fame():
-    entries = []
-    if os.path.exists("feedback_log.csv"):
-        with open("feedback_log.csv", newline='', encoding='utf-8') as f:
-            reader = csv.DictReader(f)
-            for row in reader:
-                try:
-                    score = float(row.get("evo_was_correct", "0") == "yes")
-                    if "👍" in row.get("feedback", "") or score > 0.85:
-                        entries.append(row)
-                except:
-                    continue
-    return entries[-10:][::-1]  # last 10, reverse order
-
-def handle_query(question, option1, option2, context):
-    options = [option1, option2]
-    evo_answer, evo_reasoning, evo_score, evo_context = get_evo_response(question, options, context)
-    gpt_answer = get_gpt_response(question, context)
-    return (
-        f"Answer: {evo_answer} (Confidence: {evo_score:.2f})\n\nReasoning: {evo_reasoning}\n\nContext used: {evo_context[:400]}...",
-        gpt_answer,
-        f"{question} | {context} | {evo_answer}"
-    )
-
-def handle_feedback(feedback_text, question, option1, option2, context, evo_output):
-    evo_was_correct = "👍" in feedback_text
-    log_feedback(question, option1, option2, context, evo_output, evo_was_correct)
-    return "✅ Feedback logged and Evo will improve."
-
-def trigger_retrain():
-    try:
-        subprocess.run(["python", "retrain_from_feedback.py"], check=True)
-        return "🔁 Evo retraining completed."
-    except subprocess.CalledProcessError:
-        return "❌ Retraining failed. Check logs."
-
-def render_hof():
-    entries = load_hall_of_fame()
-    if not entries:
-        return "No Hall of Fame entries yet. Submit feedback!"
-    result = "\n\n".join(
-        [
-            f"🏆 **Q:** {e['question']}\n**A:** {e['evo_output']}\n**Feedback:** {e.get('feedback', 'N/A')}\n**Context:** {e['context'][:200]}..."
-            for e in entries
-        ]
-    )
-    return result
-
-description = """
-# 🧠 EvoRAG – Adaptive Reasoning AI
-
-**What is Evo?**  
-EvoTransformer is a lightweight, evolving neural network with ~28M parameters.  
-It learns from feedback, adapts over time, and reasons using both web and context data.  
-
-**Why Evo?**  
-✅ Evolves from human input  
-✅ Architecturally updatable  
-✅ Transparent and fine-tunable  
-✅ Efficient on modest hardware
-
-**Hardware**: Trained on Google Colab CPU/GPU  
-**Token limit**: 128  
-**Benchmark**: PIQA, HellaSwag, ARC  
-**Version**: Evo v2.2 (Memory + Web Retrieval + Feedback Learning)
-"""
-
-with gr.Blocks(title="EvoRAG") as demo:
-    gr.Markdown(description)
-    with gr.Row():
-        question = gr.Textbox(label="📝 Ask anything", placeholder="e.g., What’s the best way to escape a house fire?")
-    with gr.Row():
-        option1 = gr.Textbox(label="Option A", placeholder="e.g., Run outside")
-        option2 = gr.Textbox(label="Option B", placeholder="e.g., Hide under bed")
-    context = gr.Textbox(label="📂 Optional Context", placeholder="Paste any extra background info here", lines=3)
-
-    submit_btn = gr.Button("🔍 Run Comparison")
-    with gr.Row():
-        evo_output = gr.Textbox(label="🧠 EvoRAG's Reasoned Answer", lines=6)
-        gpt_output = gr.Textbox(label="🤖 GPT-3.5's Suggestion", lines=6)
-
-    feedback = gr.Radio(["👍 Evo was correct. Retrain from this.", "👎 Evo was wrong. Don't retrain."], label="Was Evo’s answer useful?", value=None)
-    submit_feedback = gr.Button("📬 Submit Feedback")
-    feedback_status = gr.Textbox(label="Feedback Status", interactive=False)
-
-    retrain_button = gr.Button("🔄 Retrain Evo Now")
-    retrain_status = gr.Textbox(label="Retraining Status", interactive=False)
-
-    with gr.Accordion("🏆 Evo Hall of Fame (Top Reasoning Entries)", open=False):
-        hof_display = gr.Markdown(render_hof())
+# Global chat history buffer
+chat_history = []
 
-    submit_btn.click(fn=handle_query, inputs=[question, option1, option2, context], outputs=[evo_output, gpt_output, feedback_status])
-    submit_feedback.click(
-        fn=lambda fb, q, o1, o2, ctx, eo: handle_feedback(fb, q, o1, o2, ctx, eo),
-        inputs=[feedback, question, option1, option2, context, feedback_status],
-        outputs=[feedback_status]
-    )
-    retrain_button.click(fn=trigger_retrain, inputs=[], outputs=[retrain_status])
+# 🧠 Main chat handler
+def chat_fn(user_input, option1, option2):
+    global chat_history
 
-demo.launch(server_name="0.0.0.0", server_port=7860, share=True)'''
+    # Validate input
+    if not user_input or not option1 or not option2:
+        return "Please enter a message and both options.", chat_history
 
-import gradio as gr
-import torch
-import time
-import os
-from inference import load_model_and_tokenizer, infer
-from logger import log_feedback
-from retrain_from_feedback import train_evo
-from datetime import datetime
-from inference import get_gpt_response 
-
-# Globals
-model, tokenizer = load_model_and_tokenizer()
-
-# Helper to reload model
-def reload_model():
-    global model, tokenizer
-    model, tokenizer = load_model_and_tokenizer()
+    options = [option1.strip(), option2.strip()]
+    result = evo_chat_predict(chat_history, user_input, options)
 
-# Get last update time
-def get_last_update():
-    if os.path.exists("last_updated.txt"):
-        with open("last_updated.txt") as f:
-            return f.read().strip()
-    return "Never"
+    # Format Evo reply
+    evo_response = f"**Answer:** {result['answer']}  \n**Reasoning:** {result['reasoning']}"
+    chat_history.append(f"User: {user_input}")
+    chat_history.append(f"Evo: {evo_response}")
 
-# Summarize Evo architecture
-def get_model_summary():
-    num_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
-    summary = f"""
-    • 🔢 Parameters: {num_params:,}
-    • 🧱 Layers: 6 TransformerEncoder
-    • 🎯 Attention Heads: 8
-    • 🧠 FFN Dim: 1024
-    • 🧬 Memory Module: Enabled
-    • ⚙️ Pooling: AdaptiveAvgPool1d
-    • 🧾 Classifier: Linear(512 → 1)
-    """
-    return summary.strip()
+    return evo_response, chat_history
 
-# Handle inference
-def compare(question, option1, option2, context):
-    evo_ans, evo_score, evo_reason, evo_ctx = infer(question, [option1, option2], context)
-    gpt_ans = get_gpt_response(question, context)
-    return (
-        f"Answer: {evo_ans} (Confidence: {evo_score:.2f})\n\nReasoning: {evo_reason}\n\nContext used: {evo_ctx}",
-        gpt_ans
-    )
+# 🔁 Reset chat history
+def clear_fn():
+    global chat_history
+    chat_history = []
+    return "", "", "", []
 
-# Handle feedback
-def handle_feedback(feedback_text, question, option1, option2, context, evo_output):
-    evo_was_correct = feedback_text.strip().lower() == "👍 evo was correct. retrain from this."
-    log_feedback(question, option1, option2, context, evo_output, evo_was_correct)
-    return "✅ Feedback logged and Evo will improve."
-
-# Manual retrain
-def manual_retrain():
+# 🔁 Trigger Evo retraining
+def retrain_model():
     try:
-        train_evo()
-        reload_model()
-        ts = datetime.utcnow().strftime("%Y-%m-%d %H:%M GMT")
-        with open("last_updated.txt", "w") as f:
-            f.write(ts)
-        return f"✅ Evo successfully evolved! Reloaded at {ts}"
+        subprocess.run(["python", "retrain_from_feedback.py"], check=True)
+        return "✅ Evo retrained successfully."
     except Exception as e:
         return f"❌ Retraining failed: {str(e)}"
 
-with gr.Blocks(title="EvoRAG – Adaptive Reasoning AI", theme=gr.themes.Soft()) as demo:
-    gr.Markdown(f"""
-    # EvoRAG – Adaptive Reasoning AI
-    **What is Evo?**  
-    EvoTransformer is a lightweight, evolving neural network with ~28M parameters.  
-    It learns from feedback, adapts over time, and reasons using both web and context data.
-
-    **Why Evo?**  
-    ✅ Evolves from human input  
-    ✅ Architecturally updatable  
-    ✅ Transparent and fine-tunable  
-    ✅ Efficient on modest hardware  
-
-    **Hardware:** Trained on Google Colab CPU/GPU  
-    **Token limit:** 128  
-    **Benchmark:** PIQA, HellaSwag, ARC  
-    **Version:** Evo v2.2 (Memory + Web Retrieval + Feedback Learning)  
-    **🕒 Last Evolution:** {get_last_update()}
-    """)
-
-    gr.Markdown(f"""
-    ## 🧠 EvoTransformer Architecture Summary
-    {get_model_summary()}
-    """)
-
-    with gr.Row():
-        question = gr.Textbox(label="Ask anything", placeholder="e.g. What’s the best way to boil water?")
-
-    with gr.Row():
-        option1 = gr.Textbox(label="Option A")
-        option2 = gr.Textbox(label="Option B")
-
-    context = gr.Textbox(label="📂 Optional Context", lines=2, placeholder="Paste any extra background info here")
-
-    run_btn = gr.Button("🔍 Run Comparison")
-
-    with gr.Row():
-        evo_out = gr.Textbox(label="🧠 EvoRAG's Reasoned Answer")
-        gpt_out = gr.Textbox(label="🤖 GPT-3.5's Suggestion")
-
-    with gr.Row():
-        feedback_dropdown = gr.Dropdown([
-            "👍 Evo was correct. Retrain from this.",
-            "👎 Evo was wrong. Don't retrain."
-        ], label="Was Evo’s answer useful?")
-        submit_btn = gr.Button("📬 Submit Feedback")
-
-    feedback_status = gr.Textbox(label="Feedback Status")
+# 🧠 Gradio UI layout
+with gr.Blocks(title="EvoRAG – Real-Time Adaptive Reasoning AI") as demo:
+    gr.Markdown("## 🧬 EvoRAG – The Evolving Reasoning AI")
+    gr.Markdown("Ask a question, give two options, and Evo will decide with confidence. Then, retrain it live.")
 
     with gr.Row():
-        retrain_btn = gr.Button("🔄 Retrain Evo Now")
-        retrain_status = gr.Textbox(label="Retraining Status")
+        with gr.Column(scale=4):
+            user_input = gr.Textbox(label="Your Question", lines=2)
+            option1 = gr.Textbox(label="Option 1")
+            option2 = gr.Textbox(label="Option 2")
+            submit = gr.Button("🧠 Ask Evo")
+            clear = gr.Button("🔁 Clear")
+            retrain = gr.Button("📈 Retrain Evo from Feedback")
 
-    hall = gr.Markdown("""
-    ## 🏆 Evo Hall of Fame (Top Reasoning Entries)
-    *(Coming soon)*
-    """)
+        with gr.Column(scale=6):
+            evo_reply = gr.Markdown()
+            chat_display = gr.HighlightedText(label="Conversation History")
 
-    run_btn.click(fn=compare, inputs=[question, option1, option2, context], outputs=[evo_out, gpt_out])
-    submit_btn.click(fn=lambda fb, q, o1, o2, ctx, eo: handle_feedback(fb, q, o1, o2, ctx, eo),
-                     inputs=[feedback_dropdown, question, option1, option2, context, evo_out],
-                     outputs=feedback_status)
-    retrain_btn.click(fn=manual_retrain, outputs=retrain_status)
+    submit.click(fn=chat_fn, inputs=[user_input, option1, option2],
+                 outputs=[evo_reply, chat_display])
+    clear.click(fn=clear_fn, inputs=[], outputs=[user_input, option1, option2, chat_display])
+    retrain.click(fn=retrain_model, inputs=[], outputs=evo_reply)
 
 demo.launch()