Update inference.py

inference.py

@@ -1,8 +1,16 @@
+# inference.py
+
 import torch
 import torch.nn.functional as F
 from transformers import AutoTokenizer
 from evo_model import EvoTransformerV22
-from evo_architecture import build_model_from_config, mutate_genome, log_genome
+from evo_architecture import (
+    build_model_from_config,
+    mutate_genome,
+    log_genome,
+    save_best_genome,
+    load_best_genome
+)
 import random
 import csv
 import os
@@ -10,27 +18,28 @@ import psutil
 import platform
 import GPUtil
 import openai
+import pandas as pd
+
+# 🔐 Load OpenAI key
+openai.api_key = os.getenv("OPENAI_API_KEY", "sk-...")
 
-# Load tokenizer
+# ⚙️ Runtime setup
 tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-model = EvoTransformerV22().to(device)
+
+# 🔁 Mutable model & config
+current_config = load_best_genome()
+model = build_model_from_config(current_config).to(device)
 model.eval()
 
-current_config = {
-    "d_model": 512,
-    "num_heads": 8,
-    "ffn_dim": 1024,
-    "num_layers": 6,
-    "memory_enabled": True
-}
 FEEDBACK_LOG = "feedback_log.csv"
 
+# 🧠 Evo prediction
 def evo_chat_predict(history, question, options):
-    combined_inputs = [f"{question} {opt}" for opt in options]
-    encodings = tokenizer(combined_inputs, padding=True, truncation=True, max_length=128, return_tensors="pt").to(device)
+    inputs = [f"{question} {opt}" for opt in options]
+    enc = tokenizer(inputs, padding=True, truncation=True, max_length=128, return_tensors="pt").to(device)
     with torch.no_grad():
-        logits = model(encodings["input_ids"])
+        logits = model(enc["input_ids"])
         probs = torch.sigmoid(logits).squeeze().tolist()
     best_idx = int(torch.argmax(torch.tensor(probs)))
     reasoning = f"{options[0]}: {probs[0]:.3f} vs {options[1]}: {probs[1]:.3f}"
@@ -41,9 +50,8 @@ def evo_chat_predict(history, question, options):
         "context_used": question
     }
 
+# 🤖 GPT comparison
 def get_gpt_response(prompt):
-    openai.api_key = os.getenv("OPENAI_API_KEY", "sk-...")
-
     try:
         client = openai.OpenAI()
         response = client.chat.completions.create(
@@ -54,15 +62,17 @@ def get_gpt_response(prompt):
     except Exception as e:
         return f"(GPT Error) {e}"
 
+# 📊 Evo stats
 def get_model_config():
     return {
-        "num_layers": current_config["num_layers"],
-        "num_heads": current_config["num_heads"],
-        "ffn_dim": current_config["ffn_dim"],
-        "memory_enabled": current_config["memory_enabled"],
-        "accuracy": "N/A"
+        "num_layers": current_config.get("num_layers", "?"),
+        "num_heads": current_config.get("num_heads", "?"),
+        "ffn_dim": current_config.get("ffn_dim", "?"),
+        "memory_enabled": current_config.get("memory_enabled", "?"),
+        "accuracy": current_config.get("accuracy", "N/A")
     }
 
+# 🖥️ System info
 def get_system_stats():
     mem = psutil.virtual_memory()
     cpu = psutil.cpu_percent()
@@ -86,57 +96,40 @@ def get_system_stats():
         "platform": platform.platform()
     }
 
+# 🔁 Retrain from feedback
 def retrain_from_feedback_csv():
-    import pandas as pd
-    from evo_architecture import mutate_genome, log_genome, save_best_genome, build_model_from_config
-    from train_utils import train_model_on_feedback  # your training function
+    global current_config, model
 
-    if not os.path.exists("feedback_log.csv"):
+    if not os.path.exists(FEEDBACK_LOG):
         return "⚠️ No feedback log found."
 
-    df = pd.read_csv("feedback_log.csv")
+    df = pd.read_csv(FEEDBACK_LOG)
 
+    # Validate votes
     if df.empty or "vote" not in df.columns or df["vote"].dropna().empty:
-        return "⚠️ No usable feedback data. Make sure you selected Evo or GPT in previous interactions."
+        return "⚠️ No usable feedback data. Please vote on Evo or GPT."
 
-    # Filter only rows with valid vote
     df = df[df["vote"].isin(["Evo", "GPT"])]
-
     if df.empty:
-        return "⚠️ No usable feedback data. Please vote on Evo or GPT in previous questions."
-
-    # Proceed with mutation & training...
-    new_config = mutate_genome(load_best_genome())
-    log_genome(new_config)
-
-    model = build_model_from_config(new_config)
-    score = train_model_on_feedback(model, df)  # this should return a score or accuracy
-    save_best_genome({**new_config, "accuracy": score})
-
-    return f"✅ Evo retrained using feedback (score={score:.4f})"
-
+        return "⚠️ No usable feedback data. Please vote on Evo or GPT."
 
+    # Prepare training data
     data = []
-    with open(FEEDBACK_LOG, "r", encoding="utf-8") as f:
-        reader = csv.DictReader(f)
-        for row in reader:
-            vote = row.get("user_preference") or row.get("vote")
-            if vote in ["Evo", "GPT"]:
-                label = 1 if vote == "Evo" else 0
-                input_text = f"{row['question']} {row['option1']} {row['option2']}"
-                data.append((input_text, label))
+    for _, row in df.iterrows():
+        label = 1 if row["vote"] == "Evo" else 0
+        text = f"{row['question']} {row['option1']} {row['option2']}"
+        data.append((text, label))
 
     if not data:
         return "⚠️ No usable feedback data."
 
-    # Mutation logic
-    global current_config, model
+    # Mutate config
     new_config = mutate_genome(current_config)
     model = build_model_from_config(new_config).to(device)
     current_config = new_config
     log_genome(new_config)
 
-    # Retrain logic
+    # Fine-tune model
     model.train()
     optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
     for epoch in range(3):
@@ -145,16 +138,17 @@ def retrain_from_feedback_csv():
             enc = tokenizer(text, padding="max_length", truncation=True, max_length=128, return_tensors="pt").to(device)
             input_ids = enc["input_ids"]
             label_tensor = torch.tensor([label], dtype=torch.float32).to(device)
-            logits = model(input_ids)
-            if logits.ndim == 2:
-                logits = logits.squeeze(1)
-            loss = F.binary_cross_entropy_with_logits(logits.squeeze(), label_tensor)
+            logits = model(input_ids).squeeze(1)
+            loss = F.binary_cross_entropy_with_logits(logits, label_tensor)
             optimizer.zero_grad()
             loss.backward()
             optimizer.step()
+
     model.eval()
+    save_best_genome({**new_config, "accuracy": "Live-Finetuned"})
     return f"✅ Evo retrained on {len(data)} feedback entries."
 
+# 🔄 Reload model
 def load_model(force_reload=False):
     global model
-    model.eval()
+    model.eval()