Update app.py

app.py

@@ -5,10 +5,10 @@ import numpy as np
 import pandas as pd
 from fastapi import FastAPI
 from pydantic import BaseModel
-from typing import List, Dict, Any
+from typing import List
 
 # ==========================================
-# 1. DEFINE THE NETWORK (Standard SAC Actor)
+# 1. NETWORK DEFINITION
 # ==========================================
 class Actor(nn.Module):
     def __init__(self, state_dim, action_dim, hidden_dim=256):
@@ -31,43 +31,24 @@ class Actor(nn.Module):
         return mean, log_std
 
 # ==========================================
-# 2. DYNAMIC SCALER (The Fix)
+# 2. DYNAMIC SCALER
 # ==========================================
 class DynamicScaler:
-    def __init__(self):
-        self.mean = None
-        self.scale = None
-        
     def fit_transform(self, data):
-        """
-        Fits to the provided history (batch x features) and scales it.
-        Returns the scaled data.
-        """
-        # Convert to numpy if list
         X = np.array(data, dtype=np.float32)
-        
-        # Calculate stats along axis 0 (time)
-        self.mean = np.mean(X, axis=0)
-        self.scale = np.std(X, axis=0)
-        
-        # Avoid division by zero
-        self.scale[self.scale < 1e-8] = 1.0
-        
-        # Z-Score Normalization: (X - Mean) / Std
-        X_scaled = (X - self.mean) / self.scale
-        
-        # Clip to remove extreme outliers (just like training)
-        X_scaled = np.clip(X_scaled, -5, 5)
-        
-        return X_scaled
+        mean = np.mean(X, axis=0)
+        scale = np.std(X, axis=0)
+        scale[scale < 1e-8] = 1.0
+        X_scaled = (X - mean) / scale
+        return np.clip(X_scaled, -5, 5)
 
 # ==========================================
-# 3. SETUP API & LOAD MODEL
+# 3. SETUP
 # ==========================================
 app = FastAPI()
 
-# Configuration
-STATE_DIM = 96 
+# !!! THE FIX: 53 DIMENSIONS !!!
+STATE_DIM = 53
 ACTION_DIM = 1
 HIDDEN_DIM = 256
 
@@ -75,60 +56,54 @@ device = torch.device("cpu")
 actor = Actor(STATE_DIM, ACTION_DIM, HIDDEN_DIM).to(device)
 scaler = DynamicScaler()
 
+# Load Model
 try:
     print("Loading model...")
     checkpoint = torch.load("sac_v9_pytorch_best_eval.pt", map_location=device)
     actor.load_state_dict(checkpoint['actor'])
     actor.eval()
-    print("✅ Model loaded successfully!")
+    print(f"✅ Model loaded! Expecting {STATE_DIM} inputs.")
 except Exception as e:
     print(f"❌ Error loading model: {e}")
 
 # ==========================================
-# 4. API ENDPOINT
+# 4. ENDPOINT
 # ==========================================
 class InputData(BaseModel):
-    # Expects a list of lists (History of features)
-    # e.g., [[feat1, feat2...], [feat1, feat2...]]
     history: List[List[float]] 
-    portfolio: List[float] # [pos, ret, dd, last_ret, last_rsi]
+    portfolio: List[float]
 
 @app.post("/predict")
 def predict(data: InputData):
     try:
-        # 1. Get History & Scale It
-        raw_history = data.history
-        
-        if len(raw_history) < 2:
-            return {"error": "Need at least 2 rows of history to calculate scaling"}
+        # 1. Scale History
+        if len(data.history) < 2:
+            return {"error": "Need at least 2 rows of history"}
             
-        # Fit scaler on history and transform
-        scaled_history = scaler.fit_transform(raw_history)
+        scaled_history = scaler.fit_transform(data.history)
+        current_market = scaled_history[-1] # This likely has ~96 features
         
-        # Take the very last row (Current State)
-        current_market_features = scaled_history[-1]
+        # 2. Prepare Portfolio (5 items)
+        portfolio = np.array(data.portfolio, dtype=np.float32)
         
-        # 2. Append Portfolio Info (Passed separately, not scaled)
-        # Note: In training, portfolio info was normalized implicitly by limits
-        # We clip it to be safe
-        portfolio_features = np.array(data.portfolio, dtype=np.float32)
-        portfolio_features = np.clip(portfolio_features, -10, 10)
+        # 3. Smart Concatenation to match 53 Inputs
+        # The model needs 53 inputs. 
+        # Structure: [Market Features (48)] + [Portfolio (5)]
         
-        # 3. Combine
-        state = np.concatenate([current_market_features, portfolio_features])
+        needed_market = STATE_DIM - len(portfolio) # 48
+        
+        # Take the first 48 market features (most important ones like RSI, MACD usually first)
+        if len(current_market) >= needed_market:
+            market_part = current_market[:needed_market]
+        else:
+            # Pad with zeros if we somehow have less
+            padding = np.zeros(needed_market - len(current_market))
+            market_part = np.concatenate([current_market, padding])
+            
+        state = np.concatenate([market_part, portfolio])
         
-        # Check size
-        if len(state) != STATE_DIM:
-            # Auto-pad with zeros if mismatch (Emergency fallback)
-            if len(state) < STATE_DIM:
-                padding = np.zeros(STATE_DIM - len(state))
-                state = np.concatenate([state, padding])
-            else:
-                state = state[:STATE_DIM]
-
         # 4. Inference
         state_tensor = torch.FloatTensor(state).unsqueeze(0).to(device)
-        
         with torch.no_grad():
             mean, _ = actor(state_tensor)
             action = torch.tanh(mean).item()
@@ -136,8 +111,7 @@ def predict(data: InputData):
         return {
             "action": action,
             "signal": "BUY" if action > 0 else "SELL",
-            "confidence": abs(action),
-            "scaled_input_sample": current_market_features[:5].tolist() # Debug
+            "confidence": abs(action)
         }
 
     except Exception as e: