Feedback loop updated

app.py

@@ -1,193 +1,239 @@
-from flask import Flask, request, jsonify
-import numpy as np
-import os
-import pickle
-
-# 🛑 NO HEAVY IMPORTS HERE (Lazy Loading to prevent 500 Errors)
-
-app = Flask(__name__)
-
-# Global Cache
-model_cache = {
-    "lucid": None,
-    "mouse": None,
-    "fusion": None,
-    "loaded": False,
-    "error": None,
-    "logs": []
-}
-
-def load_heavy_brains():
-    """Loads libraries and models safely."""
-    # 1. If already loaded, return the logs from the first time
-    if model_cache["loaded"]: 
-        return model_cache["logs"]
-
-    log = []
-    try:
-        log.append("⏳ Importing TensorFlow...")
-        import tensorflow as tf
-        log.append("✅ TensorFlow Imported")
-        
-        log.append("⏳ Importing XGBoost...")
-        import xgboost as xgb
-        log.append("✅ XGBoost Imported")
-
-        # Define Architecture
-        Sequential = tf.keras.models.Sequential
-        Input = tf.keras.layers.Input
-        LSTM = tf.keras.layers.LSTM
-        Dense = tf.keras.layers.Dense
-        Dropout = tf.keras.layers.Dropout
-        BatchNormalization = tf.keras.layers.BatchNormalization
-        LeakyReLU = tf.keras.layers.LeakyReLU
-
-        # Load LUCID
-        if os.path.exists("lucid_cnn.h5"):
-            model_cache["lucid"] = tf.keras.models.load_model("lucid_cnn.h5")
-            log.append("✅ LUCID Model Loaded")
-        else:
-            log.append("⚠️ lucid_cnn.h5 missing")
-
-        # Load MOUSE
-        if os.path.exists("delbot_rnn.h5"):
-            mouse_model = Sequential([
-                Input(shape=(None, 10)),
-                LSTM(128, return_sequences=True, recurrent_dropout=0.0),
-                BatchNormalization(),
-                LeakyReLU(alpha=0.1),
-                Dropout(0.3),
-                LSTM(64, return_sequences=False, recurrent_dropout=0.0),
-                LeakyReLU(alpha=0.1),
-                Dropout(0.1),
-                Dense(2, activation='softmax')
-            ])
-            mouse_model.load_weights("delbot_rnn.h5")
-            model_cache["mouse"] = mouse_model
-            log.append("✅ Mouse Model Loaded")
-        else:
-            log.append("⚠️ delbot_rnn.h5 missing")
-
-        # Load FUSION
-        if os.path.exists("fusion_xgboost.pkl"):
-            with open("fusion_xgboost.pkl", "rb") as f:
-                model_cache["fusion"] = pickle.load(f)
-            log.append("✅ Fusion Model Loaded")
-        else:
-            log.append("⚠️ fusion_xgboost.pkl missing")
-
-        model_cache["loaded"] = True
-        model_cache["logs"] = log
-        return log
-
-    except Exception as e:
-        err_msg = f"❌ CRITICAL LOAD ERROR: {str(e)}"
-        print(err_msg)
-        model_cache["error"] = err_msg
-        return log + [err_msg]
-
-# --- HELPER: DATA TRANSLATOR ---
-def process_mouse_data(trace):
-    try:
-        import numpy as np 
-        MAX_STEPS = 60
-        if not trace or len(trace) < 2: return None
-        
-        vectors = []
-        for i in range(1, len(trace)):
-            dt = (trace[i]['t'] - trace[i-1]['t']) or 1
-            dx = trace[i]['x'] - trace[i-1]['x']
-            dy = trace[i]['y'] - trace[i-1]['y']
-            angle = np.arctan2(dy, dx)
-            vectors.append([dx, dy, dt, dx/dt, dy/dt, angle, 0.0, 0.0, 0.0, 0.0])
-
-        data = np.array(vectors)
-        if len(data) > MAX_STEPS: data = data[:MAX_STEPS]
-        elif len(data) < MAX_STEPS:
-            data = np.vstack([data, np.zeros((MAX_STEPS - len(data), 10))])
-        return np.expand_dims(data, axis=0)
-    except: return None
-
-@app.route('/')
-def home():
-    return "<h3>Bot Detection Server (JSON Fix Applied)</h3>Status: 🟢 Running"
-
-@app.route('/detect', methods=['POST'])
-def detect():
-    # 1. Load Brains
-    load_logs = load_heavy_brains()
-    if load_logs is None: load_logs = [] # Safety fix for NoneType error
-
-    if model_cache["error"]:
-        return jsonify({
-            "success": False, 
-            "error": "Model Load Failed", 
-            "details": model_cache["error"]
-        })
-
-    # 2. Predict
-    try:
-        data = request.json or {}
-        botd = float(data.get('botd_score', 0.0))
-        mouse_trace = data.get('mouse_trace', [])
-        ts = data.get('request_timestamps', [])
-
-        mouse_score = 0.5
-        net_score = 0.0
-
-        # Mouse
-        if model_cache["mouse"]:
-            inp = process_mouse_data(mouse_trace)
-            if inp is not None:
-                # FLOAT() CASTING HERE IS CRITICAL
-                raw_score = model_cache["mouse"].predict(inp, verbose=0)[0][1]
-                mouse_score = float(raw_score)
-
-        # Net
-        if model_cache["lucid"] and len(ts) > 2:
-            import numpy as np
-            iat = np.diff(sorted(ts))[:10] / 1000.0
-            mat = np.zeros((1, 10, 11, 1))
-            l = min(len(iat), 10)
-            mat[0, :l, 0, 0] = iat[:l]
-            # FLOAT() CASTING HERE
-            raw_net = model_cache["lucid"].predict(mat, verbose=0)[0][0]
-            net_score = float(raw_net)
-
-        # Fusion
-        final_prob = max(botd, mouse_score)
-        if model_cache["fusion"]:
-            # FLOAT() CASTING HERE
-            raw_fusion = model_cache["fusion"].predict_proba([[botd, mouse_score, net_score]])[0][1]
-            final_prob = float(raw_fusion)
-
-        # Logic
-        pct = float(final_prob * 100) # Force Python Float
-        
-        if pct > 85: decision, action, is_bot = "BOT", "BLOCK", True
-        elif pct > 50: decision, action, is_bot = "SUSPICIOUS", "CAPTCHA", True
-        else: decision, action, is_bot = "HUMAN", "ALLOW", False
-
-        return jsonify({
-            "success": True,
-            "is_bot": is_bot,
-            "action": action,
-            "decision": decision,
-            "confidence": round(pct, 2),
-            "forensics": {
-                "botd": round(botd, 2),
-                "mouse": round(mouse_score, 2),
-                "net": round(net_score, 2)
-            },
-            "internal_logs": load_logs
-        })
-
-    except Exception as e:
-        return jsonify({
-            "success": False, 
-            "error": f"Prediction Error: {str(e)}",
-            "internal_logs": load_logs
-        })
-
-if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=7860)
+from flask import Flask, request, jsonify
+import numpy as np
+import os
+import pickle
+import uuid
+import json
+from datetime import datetime
+
+# 🛑 NO HEAVY IMPORTS HERE (Lazy Loading to prevent 500 Errors)
+
+app = Flask(__name__)
+
+# Global Cache
+model_cache = {
+    "lucid": None,
+    "mouse": None,
+    "fusion": None,
+    "loaded": False,
+    "error": None,
+    "logs": []
+}
+
+# ------------------ LOGGING HELPERS ------------------
+
+def log_prediction(req_id, payload, output):
+    record = {
+        "request_id": req_id,
+        "time": datetime.utcnow().isoformat(),
+        "input": payload,
+        "output": output
+    }
+    with open("predictions.log", "a") as f:
+        f.write(json.dumps(record) + "\n")
+
+def log_feedback(feedback):
+    feedback["time"] = datetime.utcnow().isoformat()
+    with open("feedback.log", "a") as f:
+        f.write(json.dumps(feedback) + "\n")
+
+# ------------------ MODEL LOADING ------------------
+
+def load_heavy_brains():
+    if model_cache["loaded"]:
+        return []
+
+    log = []
+    try:
+        log.append("⏳ Importing TensorFlow...")
+        import tensorflow as tf
+        log.append("✅ TensorFlow Imported")
+
+        log.append("⏳ Importing XGBoost...")
+        import xgboost as xgb
+        log.append("✅ XGBoost Imported")
+
+        Sequential = tf.keras.models.Sequential
+        Input = tf.keras.layers.Input
+        LSTM = tf.keras.layers.LSTM
+        Dense = tf.keras.layers.Dense
+        Dropout = tf.keras.layers.Dropout
+        BatchNormalization = tf.keras.layers.BatchNormalization
+        LeakyReLU = tf.keras.layers.LeakyReLU
+
+        if os.path.exists("lucid_cnn.h5"):
+            model_cache["lucid"] = tf.keras.models.load_model("lucid_cnn.h5")
+            log.append("✅ LUCID Model Loaded")
+        else:
+            log.append("⚠️ lucid_cnn.h5 missing")
+
+        if os.path.exists("delbot_rnn.h5"):
+            mouse_model = Sequential([
+                Input(shape=(None, 10)),
+                LSTM(128, return_sequences=True),
+                BatchNormalization(),
+                LeakyReLU(alpha=0.1),
+                Dropout(0.3),
+                LSTM(64),
+                LeakyReLU(alpha=0.1),
+                Dropout(0.1),
+                Dense(2, activation='softmax')
+            ])
+            mouse_model.load_weights("delbot_rnn.h5")
+            model_cache["mouse"] = mouse_model
+            log.append("✅ Mouse Model Loaded")
+        else:
+            log.append("⚠️ delbot_rnn.h5 missing")
+
+        if os.path.exists("fusion_xgboost.pkl"):
+            with open("fusion_xgboost.pkl", "rb") as f:
+                model_cache["fusion"] = pickle.load(f)
+            log.append("✅ Fusion Model Loaded")
+        else:
+            log.append("⚠️ fusion_xgboost.pkl missing")
+
+        model_cache["loaded"] = True
+        model_cache["logs"] = log
+        return log
+
+    except Exception as e:
+        err = f"❌ CRITICAL LOAD ERROR: {str(e)}"
+        model_cache["error"] = err
+        return log + [err]
+
+# ------------------ DATA PROCESSING ------------------
+
+def process_mouse_data(trace):
+    try:
+        MAX_STEPS = 60
+        if not trace or len(trace) < 2:
+            return None
+
+        vectors = []
+        for i in range(1, len(trace)):
+            dt = (trace[i]['t'] - trace[i-1]['t']) or 1
+            dx = trace[i]['x'] - trace[i-1]['x']
+            dy = trace[i]['y'] - trace[i-1]['y']
+            angle = np.arctan2(dy, dx)
+            vectors.append([dx, dy, dt, dx/dt, dy/dt, angle, 0, 0, 0, 0])
+
+        data = np.array(vectors)
+        if len(data) > MAX_STEPS:
+            data = data[:MAX_STEPS]
+        else:
+            data = np.vstack([data, np.zeros((MAX_STEPS - len(data), 10))])
+
+        return np.expand_dims(data, axis=0)
+    except:
+        return None
+
+# ------------------ ROUTES ------------------
+
+@app.route("/")
+def home():
+    return "<h3>Bot Detection Server</h3>Status: 🟢 Running"
+
+@app.route("/detect", methods=["POST"])
+def detect():
+    req_id = str(uuid.uuid4())
+    load_logs = load_heavy_brains()
+
+    if model_cache["error"]:
+        return jsonify({"success": False, "error": model_cache["error"]})
+
+    try:
+        data = request.json or {}
+        botd = float(data.get("botd_score", 0.0))
+        mouse_trace = data.get("mouse_trace", [])
+        ts = data.get("request_timestamps", [])
+
+        mouse_score = None
+        net_score = 0.0
+
+        if model_cache["mouse"]:
+            inp = process_mouse_data(mouse_trace)
+            if inp is not None:
+                mouse_score = float(
+                    model_cache["mouse"].predict(inp, verbose=0)[0][1]
+                )
+
+        if model_cache["lucid"] and len(ts) > 2:
+            iat = np.diff(sorted(ts))[:10] / 1000.0
+            mat = np.zeros((1, 10, 11, 1))
+            mat[0, :len(iat), 0, 0] = iat
+            net_score = float(
+                model_cache["lucid"].predict(mat, verbose=0)[0][0]
+            )
+
+        features = [
+            botd,
+            mouse_score if mouse_score is not None else 0.5,
+            net_score
+        ]
+
+        final_prob = max(features)
+        if model_cache["fusion"]:
+            final_prob = float(
+                model_cache["fusion"].predict_proba([features])[0][1]
+            )
+
+        pct = float(np.clip(final_prob, 0.0, 1.0) * 100)
+
+        if pct > 85:
+            decision, action, is_bot = "BOT", "BLOCK", True
+        elif pct > 50:
+            decision, action, is_bot = "SUSPICIOUS", "CAPTCHA", True
+        else:
+            decision, action, is_bot = "HUMAN", "ALLOW", False
+
+        response = {
+            "success": True,
+            "request_id": req_id,
+            "is_bot": is_bot,
+            "action": action,
+            "decision": decision,
+            "confidence": round(pct, 2),
+            "forensics": {
+                "botd": round(botd, 2),
+                "mouse": round(mouse_score, 2) if mouse_score is not None else None,
+                "net": round(net_score, 2)
+            },
+            "signals": {
+                "mouse_available": mouse_score is not None,
+                "net_available": net_score > 0
+            },
+            "internal_logs": load_logs
+        }
+
+        log_prediction(req_id, data, response)
+        return jsonify(response)
+
+    except Exception as e:
+        return jsonify({"success": False, "error": str(e)})
+
+@app.route("/feedback", methods=["POST"])
+def feedback():
+    """
+    {
+      "request_id": "...",
+      "actual": "HUMAN" | "BOT",
+      "source": "captcha" | "admin" | "auto"
+    }
+    """
+    fb = request.json
+    log_feedback(fb)
+    return jsonify({"success": True})
+
+# ------------------ ENTRY ------------------
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=7860)
+ 
+import threading
+from auto_retrain import retrain_loop
+
+def start_auto_retrain():
+    t = threading.Thread(target=retrain_loop, daemon=True)
+    t.start()
+
+start_auto_retrain()

auto_retrain.py

@@ -0,0 +1,89 @@
+import time
+import json
+import os
+import pickle
+from datetime import datetime, timedelta
+import numpy as np
+from xgboost import XGBClassifier
+
+# ---------------- CONFIG ----------------
+CHECK_INTERVAL = 24*60*60  # check once per day
+RETRAIN_DAYS = 30
+MIN_SAMPLES = 100
+
+PRED_FILE = "predictions.log"
+FB_FILE = "feedback.log"
+MODEL_OUT = "fusion_xgboost.pkl"
+LAST_TRAIN_FILE = "last_train.txt"
+# --------------------------------------
+
+def load_json_lines(path):
+    if not os.path.exists(path):
+        return []
+    with open(path) as f:
+        return [json.loads(line) for line in f]
+
+def should_retrain():
+    if not os.path.exists(LAST_TRAIN_FILE):
+        return True
+    last = open(LAST_TRAIN_FILE).read().strip()
+    last_date = datetime.fromisoformat(last)
+    return (datetime.utcnow() - last_date) >= timedelta(days=RETRAIN_DAYS)
+
+def retrain():
+    print("🔁 Auto-retrain: checking conditions...")
+
+    if not should_retrain():
+        print("⏳ Period not reached")
+        return
+
+    preds = load_json_lines(PRED_FILE)
+    fbs = load_json_lines(FB_FILE)
+    fb_map = {f["request_id"]: f for f in fbs}
+
+    X, y = [], []
+
+    for p in preds:
+        rid = p["request_id"]
+        if rid not in fb_map:
+            continue
+
+        f = p["output"]["forensics"]
+        X.append([
+            f["botd"],
+            f["mouse"] if f["mouse"] is not None else 0.5,
+            f["net"]
+        ])
+        y.append(1 if fb_map[rid]["actual"] == "BOT" else 0)
+
+    if len(X) < MIN_SAMPLES:
+        print(f"⚠️ Not enough feedback: {len(X)}/{MIN_SAMPLES}")
+        return
+
+    print(f"🚀 Retraining fusion model with {len(X)} samples")
+
+    model = XGBClassifier(
+        n_estimators=100,
+        max_depth=3,
+        learning_rate=0.1,
+        eval_metric="logloss",
+        use_label_encoder=False
+    )
+
+    model.fit(np.array(X), np.array(y))
+
+    with open(MODEL_OUT, "wb") as f:
+        pickle.dump(model, f)
+
+    with open(LAST_TRAIN_FILE, "w") as f:
+        f.write(datetime.utcnow().isoformat())
+
+    print("✅ Auto-retraining completed")
+
+def retrain_loop():
+    while True:
+        try:
+            retrain()
+        except Exception as e:
+            print("❌ Retrain error:", e)
+        time.sleep(CHECK_INTERVAL)