Update app.py

app.py

@@ -1,10 +1,9 @@
-"""Gradio App for Veda Programming Assistant - Gradio 6.x compatible (with math solving)"""
+"""Gradio App for Veda Programming Assistant - Fixed Distillation"""
 
 import gradio as gr
 import tensorflow as tf
 import os
 import json
-
 import re
 import ast
 import operator as op
@@ -13,37 +12,29 @@ from model import VedaProgrammingLLM
 from tokenizer import VedaTokenizer
 from database import db
 from train import VedaTrainer
-from config import MODEL_DIR
+from teacher import teacher
+from config import MODEL_DIR, DISTILLATION_ENABLED
 
 
 # --------- Globals ----------
 model = None
 tokenizer = None
-conversation_history = []  # used for building prompt context for the model
+conversation_history = []
 current_conv_id = -1
 
 
-# --------- Helpers (Gradio message parsing) ----------
+# --------- Helpers ----------
 def extract_text(message):
-    """
-    Convert Gradio multimodal / messages objects -> plain string.
-    Handles:
-    - str
-    - dict: {"text": "..."} or {"content": "..."}
-    - list of parts: [{"type":"text","text":"..."}]
-    """
     if message is None:
         return ""
     if isinstance(message, str):
         return message
-
     if isinstance(message, dict):
         if "text" in message:
             return str(message.get("text", ""))
         if "content" in message:
             return extract_text(message["content"])
         return ""
-
     if isinstance(message, list):
         parts = []
         for part in message:
@@ -52,33 +43,17 @@ def extract_text(message):
             elif isinstance(part, str):
                 parts.append(part)
         return "".join(parts).strip()
-
     return str(message)
 
 
 def ensure_messages_history(history):
-    """
-    Ensure Chatbot history is ALWAYS messages format:
-    [{"role":"user","content":"..."}, {"role":"assistant","content":"..."}]
-
-    Also converts old tuple format [(user, bot), ...] -> messages.
-    """
     if history is None:
         return []
-
-    # Already messages format
-    if (
-        len(history) > 0
-        and isinstance(history[0], dict)
-        and "role" in history[0]
-        and "content" in history[0]
-    ):
+    if len(history) > 0 and isinstance(history[0], dict) and "role" in history[0]:
         fixed = []
         for m in history:
             fixed.append({"role": m["role"], "content": extract_text(m["content"])})
         return fixed
-
-    # Tuple/pair format -> messages format
     fixed = []
     for pair in history:
         if isinstance(pair, (list, tuple)) and len(pair) == 2:
@@ -87,7 +62,7 @@ def ensure_messages_history(history):
     return fixed
 
 
-# --------- Safe Math Solver ----------
+# --------- Math Solver ----------
 _ALLOWED_OPS = {
     ast.Add: op.add,
     ast.Sub: op.sub,
@@ -101,10 +76,6 @@ _ALLOWED_OPS = {
 
 
 def safe_eval_math(expr: str):
-    """
-    Safely evaluate arithmetic expression (no variables, no function calls).
-    Supports: + - * / % ** and parentheses, integers/floats.
-    """
     node = ast.parse(expr, mode="eval").body
 
     def _eval(n):
@@ -114,45 +85,79 @@ def safe_eval_math(expr: str):
             return _ALLOWED_OPS[type(n.op)](_eval(n.left), _eval(n.right))
         if isinstance(n, ast.UnaryOp) and type(n.op) in _ALLOWED_OPS:
             return _ALLOWED_OPS[type(n.op)](_eval(n.operand))
-        raise ValueError("Unsupported expression")
+        raise ValueError("Unsupported")
 
     return _eval(node)
 
 
 def try_math_answer(user_text: str):
-    """
-    If user text looks like a pure math expression, return computed answer as string.
-    Otherwise return None.
-    Examples:
-      "2+2=?" -> "4"
-      "2^5"   -> "32"
-      "(10+5)/3" -> "5"
-    """
     if not user_text:
         return None
-
-    # Normalize common decorations
-    s = user_text.strip()
-    s = s.replace("=", "").replace("?", "").strip()
-    s = s.replace("^", "**")  # allow ^ as power
-
-    # Only allow digits/operators/parentheses/dots/spaces
+    s = user_text.strip().replace("=", "").replace("?", "").strip().replace("^", "**")
     if not re.fullmatch(r"[0-9\.\s\+\-\*\/\(\)%]+", s):
         return None
-
     try:
         val = safe_eval_math(s)
-        # pretty formatting: 4.0 -> 4
         if isinstance(val, float) and val.is_integer():
             val = int(val)
         return str(val)
-    except Exception:
+    except:
         return None
 
 
-# --------- Model init ----------
+# --------- Response Quality Check ----------
+def is_good_response(response: str) -> bool:
+    """Check if student response is good quality"""
+    if not response:
+        return False
+    
+    response = response.strip()
+    
+    # Too short
+    if len(response) < 20:
+        return False
+    
+    # Contains gibberish patterns
+    gibberish_patterns = [
+        r'\["\]',
+        r'arr\[\s*a',
+        r'print\s*\(\s*"\s*,',
+        r'=\s+=\s+=',
+        r'\[\.\]',
+        r'return\s+if\s+is',
+        r'\s{10,}',  # Too many spaces
+        r'(\w)\1{5,}',  # Repeated characters
+    ]
+    
+    for pattern in gibberish_patterns:
+        if re.search(pattern, response):
+            return False
+    
+    # Too many special characters compared to letters
+    letters = sum(1 for c in response if c.isalpha())
+    special = sum(1 for c in response if c in '[]{}()=<>|\\')
+    if letters > 0 and special / letters > 0.5:
+        return False
+    
+    # Check for common error phrases
+    error_phrases = [
+        "i'm not sure",
+        "i don't know",
+        "could you try rephrasing",
+        "error:",
+        "cannot understand",
+    ]
+    
+    response_lower = response.lower()
+    for phrase in error_phrases:
+        if phrase in response_lower:
+            return False
+    
+    return True
+
+
+# --------- Model Init ----------
 def initialize():
-    """Initialize the assistant (load if exists, else train once)."""
     global model, tokenizer
 
     print("Initializing Veda Programming Assistant...")
@@ -183,7 +188,7 @@ def initialize():
 
         print("Model loaded!")
     else:
-        print("No saved model found. Training a new model...")
+        print("Training new model...")
         trainer = VedaTrainer()
         trainer.train(epochs=15)
         model = trainer.model
@@ -192,17 +197,19 @@ def initialize():
 
 
 def clean_response(text: str) -> str:
-    """Clean the response text for display."""
+    if not text:
+        return ""
+    
     text = text.replace("<CODE>", "\n```python\n")
     text = text.replace("<ENDCODE>", "\n```\n")
-
+    
     for token in ["<PAD>", "<UNK>", "<START>", "<END>", "<USER>", "<ASSISTANT>"]:
         text = text.replace(token, "")
-
+    
     lines = text.split("\n")
     cleaned = []
     empty_count = 0
-
+    
     for line in lines:
         if line.strip() == "":
             empty_count += 1
@@ -211,38 +218,21 @@ def clean_response(text: str) -> str:
         else:
             empty_count = 0
             cleaned.append(line)
-
+    
     return "\n".join(cleaned).strip()
 
 
-def generate_response(user_input: str, temperature: float = 0.7, max_tokens: int = 200) -> str:
-    """Generate a response from the model OR solve math deterministically."""
-    global current_conv_id, conversation_history
-
-    # Convert Gradio multimodal -> text
-    user_input = extract_text(user_input).strip()
-    if not user_input:
-        return "Please type a message!"
-
-    # 1) Try math solver first
-    math_ans = try_math_answer(user_input)
-    if math_ans is not None:
-        # Save conversation too (optional)
-        conversation_history.append({"user": user_input, "assistant": math_ans})
-        current_conv_id = db.save_conversation(user_input, math_ans)
-        return math_ans
-
-    # 2) Otherwise use model
-    if model is None:
-        return "Model is loading, please wait..."
-
+def get_student_response(user_input: str, temperature: float = 0.7, max_tokens: int = 200) -> str:
+    """Get response from student model (Veda)"""
+    if model is None or tokenizer is None:
+        return ""
+    
     try:
         context = ""
         for msg in conversation_history[-3:]:
             context += f"<USER> {msg['user']}\n<ASSISTANT> {msg['assistant']}\n"
 
         prompt = context + f"<USER> {user_input}\n<ASSISTANT>"
-
         tokens = tokenizer.encode(prompt)
 
         if len(tokens) > model.max_length - max_tokens:
@@ -264,27 +254,100 @@ def generate_response(user_input: str, temperature: float = 0.7, max_tokens: int
         if "<USER>" in response:
             response = response.split("<USER>")[0].strip()
 
-        response = clean_response(response)
+        return clean_response(response)
+    
+    except Exception as e:
+        print(f"Student model error: {e}")
+        return ""
+
 
-        if not response:
-            response = "I'm not sure how to respond to that. Could you try rephrasing?"
+def get_teacher_response(user_input: str) -> str:
+    """Get response from teacher model (Dolphin Mistral)"""
+    try:
+        # Build conversation history for teacher
+        conv_history = []
+        for msg in conversation_history[-4:]:
+            conv_history.append({"role": "user", "content": msg["user"]})
+            conv_history.append({"role": "assistant", "content": msg["assistant"]})
+        
+        response = teacher.ask(
+            user_message=user_input,
+            conversation_history=conv_history,
+        )
+        
+        return response if response else ""
+    
+    except Exception as e:
+        print(f"Teacher model error: {e}")
+        return ""
 
-        conversation_history.append({"user": user_input, "assistant": response})
-        current_conv_id = db.save_conversation(user_input, response)
 
-        return response
+def generate_response(user_input: str, temperature: float = 0.7, max_tokens: int = 200) -> str:
+    """Generate a response - uses teacher if student fails"""
+    global current_conv_id, conversation_history
 
-    except Exception as e:
-        import traceback
-        traceback.print_exc()
-        return f"Error: {str(e)}"
+    user_input = extract_text(user_input).strip()
+    if not user_input:
+        return "Please type a message!"
 
+    # 1) Try math first
+    math_ans = try_math_answer(user_input)
+    if math_ans is not None:
+        conversation_history.append({"user": user_input, "assistant": math_ans})
+        current_conv_id = db.save_conversation(user_input, math_ans)
+        return math_ans
 
-# --------- Gradio handlers ----------
+    # 2) Try student model
+    print(f"[Student] Generating response for: {user_input[:50]}...")
+    student_response = get_student_response(user_input, temperature, max_tokens)
+    
+    # 3) Check if student response is good
+    if is_good_response(student_response):
+        print("[Student] Response is good quality, using it.")
+        final_response = student_response
+        source = "student"
+    else:
+        # 4) Student failed, ask teacher
+        print("[Student] Response is poor quality, asking teacher...")
+        print(f"[Student Bad Response]: {student_response[:100]}...")
+        
+        teacher_response = get_teacher_response(user_input)
+        
+        if teacher_response:
+            print("[Teacher] Got good response from teacher!")
+            final_response = teacher_response
+            source = "teacher"
+            
+            # Save for future training
+            db.save_distillation_data(
+                user_input=user_input,
+                teacher_response=teacher_response,
+                student_response=student_response,
+                quality_score=1.0,
+            )
+        else:
+            # Teacher also failed, use student response anyway
+            print("[Teacher] No response from teacher, using student response.")
+            final_response = student_response if student_response else "I'm sorry, I couldn't generate a good response. Please try again."
+            source = "student"
+
+    # 5) Save and return
+    if not final_response:
+        final_response = "I'm having trouble responding. Please try asking in a different way."
+
+    conversation_history.append({"user": user_input, "assistant": final_response})
+    current_conv_id = db.save_conversation(user_input, final_response)
+
+    # Add indicator if from teacher
+    if source == "teacher":
+        final_response = f"🎓 {final_response}"
+
+    return final_response
+
+
+# --------- Gradio Handlers ----------
 def respond(message, history, temperature, max_tokens):
-    """Always return messages-format history."""
     history = ensure_messages_history(history)
-
     user_text = extract_text(message).strip()
     if not user_text:
         return "", history
@@ -298,19 +361,17 @@ def respond(message, history, temperature, max_tokens):
 
 
 def feedback_good():
-    global current_conv_id
     if current_conv_id > 0:
         db.update_feedback(current_conv_id, 1)
-        return "👍 Thanks for the positive feedback!"
-    return "No conversation to rate yet."
+        return "👍 Thanks! This helps me learn."
+    return ""
 
 
 def feedback_bad():
-    global current_conv_id
     if current_conv_id > 0:
         db.update_feedback(current_conv_id, -1)
-        return "👎 Thanks! I'll try to improve."
-    return "No conversation to rate yet."
+        return "👎 Thanks for feedback. I'll improve!"
+    return ""
 
 
 def clear_chat():
@@ -319,56 +380,111 @@ def clear_chat():
     return [], "Chat cleared."
 
 
-def retrain(epochs):
-    """Retrain with good conversations."""
+def retrain_with_distillation(epochs):
+    """Retrain using teacher knowledge"""
     global model, tokenizer
 
+    # Get user-approved conversations
     good_convs = db.get_good_conversations()
-    if not good_convs:
-        return "No approved conversations yet. Rate some responses as 'Good' first!"
-
     extra_data = ""
     for conv in good_convs:
         extra_data += f"<USER> {conv['user_input']}\n"
         extra_data += f"<ASSISTANT> {conv['assistant_response']}\n\n"
 
+    # Get distillation data (teacher responses)
+    unused_distill = db.get_unused_distillation_data()
+    distillation_data = ""
+    for item in unused_distill:
+        distillation_data += f"<USER> {item['user_input']}\n"
+        distillation_data += f"<ASSISTANT> {item['teacher_response']}\n\n"
+
+    total_samples = len(good_convs) + len(unused_distill)
+    
+    if total_samples == 0:
+        return "❌ No training data available. Chat more and rate responses!"
+
     trainer = VedaTrainer()
-    history = trainer.train(epochs=int(epochs), extra_data=extra_data)
+    history = trainer.train(
+        epochs=int(epochs),
+        extra_data=extra_data,
+        distillation_data=distillation_data,
+    )
 
     model = trainer.model
     tokenizer = trainer.tokenizer
 
+    # Mark distillation data as used
+    if unused_distill:
+        ids = [item["id"] for item in unused_distill]
+        db.mark_distillation_used(ids)
+
     loss = history.history["loss"][-1]
-    return f"✅ Training complete! Loss: {loss:.4f}, Used {len(good_convs)} conversations"
+    
+    db.save_training_history(
+        training_type="distillation",
+        samples_used=total_samples,
+        epochs=int(epochs),
+        final_loss=loss,
+    )
+
+    return f"""✅ Training Complete!
+
+📊 **Results:**
+- Loss: {loss:.4f}
+- User samples: {len(good_convs)}
+- Teacher samples: {len(unused_distill)}
+- Total epochs: {epochs}
+
+Your model has learned from the teacher!
+"""
 
 
 def get_stats():
     stats = db.get_stats()
+    teacher_available = teacher.is_available()
+
     return f"""## 📊 Statistics
 
+### Conversations
 | Metric | Count |
 |--------|-------|
-| 💬 Total Conversations | {stats['total']} |
-| 👍 Positive Feedback | {stats['positive']} |
-| 👎 Negative Feedback | {stats['negative']} |
+| 💬 Total | {stats['total']} |
+| 👍 Positive | {stats['positive']} |
+| 👎 Negative | {stats['negative']} |
+
+### 🎓 Distillation
+| Metric | Value |
+|--------|-------|
+| Teacher Available | {'✅ Yes' if teacher_available else '❌ No'} |
+| Teacher Samples | {stats.get('distillation_total', 0)} |
+| Ready to Train | {stats.get('distillation_unused', 0)} |
 """
 
 
 # --------- Startup ----------
-print("Starting initialization...")
+print("=" * 50)
+print("Starting Veda Programming Assistant...")
+print("=" * 50)
 initialize()
-print("Initialization complete!")
+print("Checking teacher availability...")
+if teacher.is_available():
+    print("✅ Teacher model (Dolphin Mistral) is available!")
+else:
+    print("❌ Teacher model not available - check API key")
+print("=" * 50)
+print("Ready!")
+print("=" * 50)
 
 
 # --------- UI ----------
 with gr.Blocks(title="Veda Programming Assistant") as demo:
-    gr.Markdown(
-        """
+    gr.Markdown("""
 # 🕉️ Veda Programming Assistant
 
-Now supports **math** (e.g., `2+2=?`, `(10+5)/3`, `2^5`) plus coding/chatting.
-"""
-    )
+I can help you with **coding**, **programming concepts**, and **math**!
+
+*Responses marked with 🎓 come from an advanced AI teacher.*
+""")
 
     with gr.Tabs():
         with gr.TabItem("💬 Chat"):
@@ -377,7 +493,7 @@ Now supports **math** (e.g., `2+2=?`, `(10+5)/3`, `2^5`) plus coding/chatting.
             with gr.Row():
                 msg = gr.Textbox(
                     label="Your message",
-                    placeholder="Ask me anything about programming... or type math like 2+2=?",
+                    placeholder="Ask me anything about programming...",
                     lines=2,
                     scale=4,
                 )
@@ -394,9 +510,8 @@ Now supports **math** (e.g., `2+2=?`, `(10+5)/3`, `2^5`) plus coding/chatting.
 
             feedback_msg = gr.Textbox(label="Status", lines=1, interactive=False)
 
-            send_btn.click(respond, inputs=[msg, chatbot, temperature, max_tokens], outputs=[msg, chatbot])
-            msg.submit(respond, inputs=[msg, chatbot, temperature, max_tokens], outputs=[msg, chatbot])
-
+            send_btn.click(respond, [msg, chatbot, temperature, max_tokens], [msg, chatbot])
+            msg.submit(respond, [msg, chatbot, temperature, max_tokens], [msg, chatbot])
             good_btn.click(feedback_good, outputs=feedback_msg)
             bad_btn.click(feedback_bad, outputs=feedback_msg)
             clear_btn.click(clear_chat, outputs=[chatbot, feedback_msg])
@@ -404,38 +519,40 @@ Now supports **math** (e.g., `2+2=?`, `(10+5)/3`, `2^5`) plus coding/chatting.
             gr.Markdown("### 💡 Examples")
             gr.Examples(
                 examples=[
-                    ["2+2=?"],
-                    ["(10+5)/3"],
-                    ["2^8"],
+                    ["Hello! What can you do?"],
                     ["What is Python?"],
-                    ["Write a function to calculate factorial"],
+                    ["Write a factorial function"],
                     ["Explain recursion"],
+                    ["Write bubble sort"],
+                    ["2+2=?"],
+                    ["What is the difference between list and tuple?"],
                 ],
                 inputs=msg,
             )
 
         with gr.TabItem("🎓 Training"):
-            gr.Markdown(
-                """
-### Improve the Assistant
+            gr.Markdown("""
+### Improve the Model
 
-1. Chat with the assistant  
-2. Rate good responses with 👍  
-3. Click "Retrain Model" to learn from good conversations  
-"""
-            )
+The model learns from:
+1. **Your feedback** - Rate responses 👍 or 👎
+2. **Teacher knowledge** - Learns from advanced AI
 
-            train_epochs = gr.Slider(5, 20, 10, step=1, label="Training Epochs")
-            train_btn = gr.Button("🔄 Retrain Model", variant="primary")
+Click below to train with collected data.
+""")
+
+            train_epochs = gr.Slider(5, 30, 15, step=1, label="Training Epochs")
+            train_btn = gr.Button("🚀 Train Model", variant="primary")
             train_output = gr.Markdown()
-            train_btn.click(retrain, inputs=[train_epochs], outputs=train_output)
+
+            train_btn.click(retrain_with_distillation, inputs=train_epochs, outputs=train_output)
 
         with gr.TabItem("📊 Statistics"):
             stats_out = gr.Markdown()
-            refresh_btn = gr.Button("🔄 Refresh Statistics")
+            refresh_btn = gr.Button("🔄 Refresh")
             refresh_btn.click(get_stats, outputs=stats_out)
 
-    gr.Markdown("---\n**Veda Programming Assistant**")
+    gr.Markdown("---\n**Veda Programming Assistant** | Made with ❤️")
 
 
 if __name__ == "__main__":