Update app.py

app.py

@@ -1,4 +1,4 @@
-"""Gradio App for Veda Programming Assistant - Fixed Distillation"""
+"""Veda Programming Assistant - Auto Learning (Hidden Teacher)"""
 
 import gradio as gr
 import tensorflow as tf
@@ -7,13 +7,15 @@ import json
 import re
 import ast
 import operator as op
+import threading
+import time
 
 from model import VedaProgrammingLLM
 from tokenizer import VedaTokenizer
 from database import db
 from train import VedaTrainer
 from teacher import teacher
-from config import MODEL_DIR, DISTILLATION_ENABLED
+from config import MODEL_DIR
 
 
 # --------- Globals ----------
@@ -22,6 +24,14 @@ tokenizer = None
 conversation_history = []
 current_conv_id = -1
 
+# Auto-training settings
+AUTO_TRAIN_ENABLED = True
+AUTO_TRAIN_MIN_SAMPLES = 10  # Train after this many teacher responses
+AUTO_TRAIN_INTERVAL = 1800   # Check every 30 minutes (in seconds)
+AUTO_TRAIN_EPOCHS = 10
+is_training = False
+last_train_time = 0
+
 
 # --------- Helpers ----------
 def extract_text(message):
@@ -114,7 +124,7 @@ def is_good_response(response: str) -> bool:
     response = response.strip()
     
     # Too short
-    if len(response) < 20:
+    if len(response) < 30:
         return False
     
     # Contains gibberish patterns
@@ -125,27 +135,40 @@ def is_good_response(response: str) -> bool:
         r'=\s+=\s+=',
         r'\[\.\]',
         r'return\s+if\s+is',
-        r'\s{10,}',  # Too many spaces
-        r'(\w)\1{5,}',  # Repeated characters
+        r'\s{10,}',
+        r'(\w)\1{5,}',
+        r'\[\s*\]',
+        r'def\s+def',
+        r'class\s+class',
+        r'return\s+return',
+        r'if\s+if',
+        r'\(\s*\)',
+        r'=\s*=\s*=',
     ]
     
     for pattern in gibberish_patterns:
         if re.search(pattern, response):
             return False
     
-    # Too many special characters compared to letters
+    # Too many special characters
     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
+    # Too many brackets without proper code
+    brackets = response.count('[') + response.count(']') + response.count('{') + response.count('}')
+    if brackets > 20 and 'def ' not in response and 'class ' not in response:
+        return False
+    
+    # Check for error phrases
     error_phrases = [
         "i'm not sure",
         "i don't know",
         "could you try rephrasing",
         "error:",
         "cannot understand",
+        "not sure how to respond",
     ]
     
     response_lower = response.lower()
@@ -156,6 +179,76 @@ def is_good_response(response: str) -> bool:
     return True
 
 
+# --------- Auto Training ----------
+def auto_train_background():
+    """Background thread that automatically trains when enough data collected"""
+    global model, tokenizer, is_training, last_train_time
+    
+    while True:
+        time.sleep(60)  # Check every minute
+        
+        if not AUTO_TRAIN_ENABLED:
+            continue
+        
+        if is_training:
+            continue
+        
+        # Check if enough time passed since last training
+        if time.time() - last_train_time < AUTO_TRAIN_INTERVAL:
+            continue
+        
+        # Check if we have enough samples
+        try:
+            unused = db.get_unused_distillation_data()
+            if len(unused) >= AUTO_TRAIN_MIN_SAMPLES:
+                print(f"\n[Auto-Train] Starting training with {len(unused)} samples...")
+                is_training = True
+                
+                # Prepare training data
+                good_convs = db.get_good_conversations()
+                extra_data = ""
+                for conv in good_convs:
+                    extra_data += f"<USER> {conv['user_input']}\n"
+                    extra_data += f"<ASSISTANT> {conv['assistant_response']}\n\n"
+                
+                distillation_data = ""
+                for item in unused:
+                    distillation_data += f"<USER> {item['user_input']}\n"
+                    distillation_data += f"<ASSISTANT> {item['teacher_response']}\n\n"
+                
+                # Train
+                trainer = VedaTrainer()
+                history = trainer.train(
+                    epochs=AUTO_TRAIN_EPOCHS,
+                    extra_data=extra_data,
+                    distillation_data=distillation_data,
+                )
+                
+                # Update global model
+                model = trainer.model
+                tokenizer = trainer.tokenizer
+                
+                # Mark as used
+                ids = [item["id"] for item in unused]
+                db.mark_distillation_used(ids)
+                
+                loss = history.history["loss"][-1]
+                db.save_training_history(
+                    training_type="auto",
+                    samples_used=len(unused) + len(good_convs),
+                    epochs=AUTO_TRAIN_EPOCHS,
+                    final_loss=loss,
+                )
+                
+                last_train_time = time.time()
+                is_training = False
+                print(f"[Auto-Train] Completed! Loss: {loss:.4f}")
+                
+        except Exception as e:
+            print(f"[Auto-Train] Error: {e}")
+            is_training = False
+
+
 # --------- Model Init ----------
 def initialize():
     global model, tokenizer
@@ -257,14 +350,13 @@ def get_student_response(user_input: str, temperature: float = 0.7, max_tokens:
         return clean_response(response)
     
     except Exception as e:
-        print(f"Student model error: {e}")
+        print(f"Student error: {e}")
         return ""
 
 
 def get_teacher_response(user_input: str) -> str:
-    """Get response from teacher model (Dolphin Mistral)"""
+    """Get response from teacher model (hidden from user)"""
     try:
-        # Build conversation history for teacher
         conv_history = []
         for msg in conversation_history[-4:]:
             conv_history.append({"role": "user", "content": msg["user"]})
@@ -278,47 +370,39 @@ def get_teacher_response(user_input: str) -> str:
         return response if response else ""
     
     except Exception as e:
-        print(f"Teacher model error: {e}")
+        print(f"Teacher error: {e}")
         return ""
 
 
 def generate_response(user_input: str, temperature: float = 0.7, max_tokens: int = 200) -> str:
-    """Generate a response - uses teacher if student fails"""
+    """Generate response - seamlessly uses teacher when needed (hidden from user)"""
     global current_conv_id, conversation_history
 
     user_input = extract_text(user_input).strip()
     if not user_input:
         return "Please type a message!"
 
-    # 1) Try math first
+    # 1) 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
 
-    # 2) Try student model
-    print(f"[Student] Generating response for: {user_input[:50]}...")
+    # 2) Try student
     student_response = get_student_response(user_input, temperature, max_tokens)
     
-    # 3) Check if student response is good
+    # 3) Check quality
     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]}...")
-        
+        # 4) Silently ask teacher (user doesn't know!)
         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
+            # Save for auto-training (silent learning)
             db.save_distillation_data(
                 user_input=user_input,
                 teacher_response=teacher_response,
@@ -326,22 +410,15 @@ def generate_response(user_input: str, temperature: float = 0.7, max_tokens: int
                 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"
+            final_response = student_response if student_response else "I'm having trouble understanding. Could you rephrase that?"
 
-    # 5) Save and return
     if not final_response:
-        final_response = "I'm having trouble responding. Please try asking in a different way."
+        final_response = "I couldn't generate a response. Please try again."
 
     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}"
-
+    # NO indicator - user doesn't know if it's teacher or student!
     return final_response
 
 
@@ -363,14 +440,14 @@ def respond(message, history, temperature, max_tokens):
 def feedback_good():
     if current_conv_id > 0:
         db.update_feedback(current_conv_id, 1)
-        return "👍 Thanks! This helps me learn."
+        return "👍 Thanks!"
     return ""
 
 
 def feedback_bad():
     if current_conv_id > 0:
         db.update_feedback(current_conv_id, -1)
-        return "👎 Thanks for feedback. I'll improve!"
+        return "👎 Thanks for feedback!"
     return ""
 
 
@@ -380,84 +457,34 @@ def clear_chat():
     return [], "Chat cleared."
 
 
-def retrain_with_distillation(epochs):
-    """Retrain using teacher knowledge"""
-    global model, tokenizer
-
-    # Get user-approved conversations
-    good_convs = db.get_good_conversations()
-    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,
-        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]
-    
-    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()
+    
+    # Calculate learning progress
+    total_teacher = stats.get('distillation_total', 0)
+    used_teacher = total_teacher - stats.get('distillation_unused', 0)
+    
+    if total_teacher > 0:
+        learning_progress = (used_teacher / total_teacher) * 100
+    else:
+        learning_progress = 0
 
     return f"""## 📊 Statistics
 
 ### Conversations
 | Metric | Count |
 |--------|-------|
-| 💬 Total | {stats['total']} |
-| 👍 Positive | {stats['positive']} |
-| 👎 Negative | {stats['negative']} |
+| 💬 Total Chats | {stats['total']} |
+| 👍 Helpful | {stats['positive']} |
+| 👎 Needs Work | {stats['negative']} |
 
-### 🎓 Distillation
+### 🧠 Learning Progress
 | 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)} |
+| Knowledge Gained | {used_teacher} lessons |
+| Learning Queue | {stats.get('distillation_unused', 0)} pending |
+| Auto-Training | {'✅ Active' if AUTO_TRAIN_ENABLED else '❌ Disabled'} |
+| Currently Training | {'🔄 Yes' if is_training else '✅ Ready'} |
 """
 
 
@@ -465,30 +492,32 @@ def get_stats():
 print("=" * 50)
 print("Starting Veda Programming Assistant...")
 print("=" * 50)
+
 initialize()
-print("Checking teacher availability...")
-if teacher.is_available():
-    print("✅ Teacher model (Dolphin Mistral) is available!")
-else:
-    print("❌ Teacher model not available - check API key")
+
+# Start auto-training background thread
+if AUTO_TRAIN_ENABLED:
+    print("Starting auto-learning background process...")
+    train_thread = threading.Thread(target=auto_train_background, daemon=True)
+    train_thread.start()
+    print("Auto-learning enabled!")
+
 print("=" * 50)
 print("Ready!")
 print("=" * 50)
 
 
-# --------- UI ----------
+# --------- UI (Simple - No Training Tab) ----------
 with gr.Blocks(title="Veda Programming Assistant") as demo:
     gr.Markdown("""
 # 🕉️ Veda Programming Assistant
 
 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"):
-            chatbot = gr.Chatbot(label="Conversation", height=400, value=[])
+            chatbot = gr.Chatbot(label="Conversation", height=450, value=[])
 
             with gr.Row():
                 msg = gr.Textbox(
@@ -504,11 +533,11 @@ I can help you with **coding**, **programming concepts**, and **math**!
                 max_tokens = gr.Slider(50, 400, 200, step=50, label="Response length")
 
             with gr.Row():
-                good_btn = gr.Button("👍 Good", variant="secondary")
-                bad_btn = gr.Button("👎 Bad", variant="secondary")
+                good_btn = gr.Button("👍 Helpful", variant="secondary")
+                bad_btn = gr.Button("👎 Not Helpful", variant="secondary")
                 clear_btn = gr.Button("🗑️ Clear", variant="secondary")
 
-            feedback_msg = gr.Textbox(label="Status", lines=1, interactive=False)
+            feedback_msg = gr.Textbox(label="", lines=1, interactive=False, show_label=False)
 
             send_btn.click(respond, [msg, chatbot, temperature, max_tokens], [msg, chatbot])
             msg.submit(respond, [msg, chatbot, temperature, max_tokens], [msg, chatbot])
@@ -516,7 +545,7 @@ I can help you with **coding**, **programming concepts**, and **math**!
             bad_btn.click(feedback_bad, outputs=feedback_msg)
             clear_btn.click(clear_chat, outputs=[chatbot, feedback_msg])
 
-            gr.Markdown("### 💡 Examples")
+            gr.Markdown("### 💡 Try asking:")
             gr.Examples(
                 examples=[
                     ["Hello! What can you do?"],
@@ -525,34 +554,26 @@ I can help you with **coding**, **programming concepts**, and **math**!
                     ["Explain recursion"],
                     ["Write bubble sort"],
                     ["2+2=?"],
-                    ["What is the difference between list and tuple?"],
+                    ["What is a list in Python?"],
+                    ["How do I read a file?"],
                 ],
                 inputs=msg,
             )
 
-        with gr.TabItem("🎓 Training"):
-            gr.Markdown("""
-### Improve the Model
-
-The model learns from:
-1. **Your feedback** - Rate responses 👍 or 👎
-2. **Teacher knowledge** - Learns from advanced AI
-
-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_with_distillation, inputs=train_epochs, outputs=train_output)
-
-        with gr.TabItem("📊 Statistics"):
+        with gr.TabItem("📊 Stats"):
+            gr.Markdown("### How is Veda doing?")
             stats_out = gr.Markdown()
             refresh_btn = gr.Button("🔄 Refresh")
             refresh_btn.click(get_stats, outputs=stats_out)
+            
+            gr.Markdown("""
+---
+**💡 Tip:** Rate responses to help Veda learn faster!
+- 👍 = This was helpful
+- 👎 = This needs improvement
+""")
 
-    gr.Markdown("---\n**Veda Programming Assistant** | Made with ❤️")
+    gr.Markdown("---\n**Veda Programming Assistant** | Always learning, always improving!")
 
 
 if __name__ == "__main__":