Update app.py

app.py

@@ -158,38 +158,36 @@ def send_ntfy(message):
 def run_analysis():
     log_buffer = []
     
-    # 1. Initialize Models if needed
+    # 1. Initialize Models
     if GLOBAL_STATE["base_model"] is None:
         GLOBAL_STATE["base_model"] = ConstellationTransformer(input_dim=4, d_model=64)
-        # Pre-load base model with random weights (simulating a pre-trained state)
-        # In a real scenario, you'd load a .pth file here
         log_buffer.append("🧠 Base Transformer Initialized")
 
-    # 2. Initialize Shadow Model (Reset every scan to simulate 'fresh' eyes or keep persistent)
-    # We re-initialize here to prove it learns the CURRENT chart from scratch every time
+    # Always re-init shadow model for fresh "session" learning or keep it if you want long term
     GLOBAL_STATE["shadow_model"] = MetaShadowLearner(input_size=4) 
     
     base_model = GLOBAL_STATE["base_model"]
     shadow_model = GLOBAL_STATE["shadow_model"]
     
-    # 3. Get Data
+    # 2. Get Data
     master_df, msg = get_constellation_data()
     if master_df is None: return None, msg, msg
     
     X_tensor, dates, ref_prices, ret_mean, ret_std, raw_scaled_features = prepare_tensors(master_df)
     
-    # 4. THE LIVE LEARNING LOOP
-    # We iterate through the chart. The Base Model predicts. The Shadow Model observes the error and updates itself.
-    
+    # 3. THE LIVE LEARNING LOOP
     final_preds = []
     base_preds = []
     shadow_corrections = []
     
     log_buffer.append("🧬 Shadow Model learning on the spot...")
     
-    base_model.eval() # Base model is frozen/static
+    base_model.eval()
+    
+    # We iterate up to len-1 because we need the 'next' value to calculate error
+    loop_limit = len(X_tensor) - 1
     
-    for i in range(len(X_tensor) - 1): # -1 because we need target for next step
+    for i in range(loop_limit):
         
         # A. Base Model Prediction
         with torch.no_grad():
@@ -200,13 +198,10 @@ def run_analysis():
             base_sigma = sigma[0, max_idx].item()
         
         # B. Construct Shadow Inputs
-        # The Shadow sees: [Base_Prediction, Base_Confidence, Recent_Volatility, Current_Price_Trend]
-        # Using raw scaled features from the last step of the window
         last_features = raw_scaled_features[LOOKBACK + i - 1] 
-        # Feature vector: [Base_Pred, Base_Sigma, Volatility(approx via EURUSD ret), Gold_Ret]
         shadow_input = torch.tensor([[base_pred_ret, base_sigma, last_features[0], last_features[3]]], dtype=torch.float32)
         
-        # C. Shadow Prediction (Before knowing the truth)
+        # C. Shadow Prediction
         with torch.no_grad():
             correction = shadow_model(shadow_input).item()
         
@@ -219,45 +214,54 @@ def run_analysis():
         # E. Base Model Error
         base_error = actual_ret_scaled - base_pred_ret
         
-        # F. TEACH THE SHADOW (On The Spot!)
-        # Target for shadow is the Base Model's error
+        # F. TEACH THE SHADOW
         target_tensor = torch.tensor([[base_error]], dtype=torch.float32)
-        
-        # This function updates the weights of shadow_model instantly
         shadow_model.learn_on_the_spot(shadow_input, target_tensor)
         
-        # Store for plotting
         base_preds.append(base_pred_ret)
         shadow_corrections.append(correction)
         final_preds.append(final_ret_pred)
 
-    # Convert predictions back to price
-    plot_dates = dates[1:-1]
-    plot_actual = ref_prices[1:-1]
+    # --- FIXING THE ARRAY ALIGNMENT ---
+    # The loop runs 'loop_limit' times.
+    # If len(X) is 100, loop_limit is 99.
+    # We generated 99 predictions.
+    # Prediction i=0 corresponds to the move from Price[0] to Price[1].
+    # So we align with dates[1:] and ref_prices[1:].
     
-    # Reconstruct Prices
+    # Slice the data to match the prediction count
+    plot_dates = dates[1:1+len(final_preds)]
+    plot_actual = ref_prices[1:1+len(final_preds)]
+    
+    # Reconstruction
     pred_prices = []
-    curr_price = ref_prices[0]
+    curr_price = ref_prices[0] # Start from known point
     
-    for ret in final_preds:
-        # Denormalize return
+    for k, ret in enumerate(final_preds):
         real_ret = (ret * ret_std) + ret_mean
-        next_price = curr_price * (1 + real_ret)
+        # To avoid compounding error drift in visualization, we use the ACTUAL previous price
+        # to calculate the NEXT predicted price.
+        prev_actual_price = ref_prices[k] 
+        next_price = prev_actual_price * (1 + real_ret)
         pred_prices.append(next_price)
-        curr_price = ref_prices[len(pred_prices)] # Reset to actual to prevent drift for visual comparison
 
-    # Create DataFrame
-    df = pd.DataFrame({
-        'Close': plot_actual,
-        'Final_Pred': pred_prices,
-        'Base_Pred': [ref_prices[k] * (1 + (bp * ret_std) + ret_mean) for k, bp in enumerate(base_preds)],
-        'Correction': shadow_corrections
-    }, index=plot_dates)
+    # Create DataFrame (Safe Mode)
+    try:
+        df = pd.DataFrame({
+            'Close': plot_actual,
+            'Final_Pred': pred_prices,
+            'Base_Pred': [ref_prices[k] * (1 + (bp * ret_std) + ret_mean) for k, bp in enumerate(base_preds)],
+            'Correction': shadow_corrections
+        }, index=plot_dates)
+    except ValueError as e:
+        return None, f"❌ Data Size Mismatch: {e}", "\n".join(log_buffer)
 
-    # Calculate Z-Score on the FINAL Optimized prediction
+    # Calculate Z-Score
     df['Gap'] = df['Final_Pred'] - df['Close']
     df['Z_Score'] = (df['Gap'] - df['Gap'].rolling(50).mean()) / (df['Gap'].rolling(50).std() + 1e-9)
     
+    if len(df) < 2: return None, "Not enough data yet.", "Waiting..."
+
     last_z = df['Z_Score'].iloc[-1]
     last_price = df['Close'].iloc[-1]
     
@@ -324,7 +328,7 @@ def background_loop():
             print("✅ Scan Complete. Sleeping...")
         except Exception as e:
             print(f"❌ Background Error: {e}")
-        time.sleep(300) # Run every 5 minutes (900 seconds)
+        time.sleep(400) # Run every 5 minutes (900 seconds)
 
 # Start Background Thread
 t = threading.Thread(target=background_loop, daemon=True)