Update main.py

main.py

@@ -1,406 +1,411 @@
-import torch
-import torch.nn as nn
-import numpy as np
-import joblib
-import random
-import os
-from fastapi import FastAPI
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
-from contextlib import asynccontextmanager
-
-# ==========================================
-# 1. CORE COMPONENTS (SYNTAX-VALIDATED)
-# ==========================================
-class Mish(nn.Module):
-    def forward(self, x):
-        return x * torch.tanh(nn.functional.softplus(x))
-
-class FourierFeatureMapping(nn.Module):
-    def __init__(self, input_dim, mapping_size, scale=10.0):
-        super().__init__()
-        self.register_buffer('B', torch.randn(input_dim, mapping_size) * scale)
-    
-    def forward(self, x):
-        proj = 2 * np.pi * (x @ self.B)
-        return torch.cat([torch.sin(proj), torch.cos(proj)], dim=-1)
-
-# ==========================================
-# 2. AUDIT-COMPLIANT ARCHITECTURES (EXACT TENSOR MATCH)
-# ==========================================
-class SolarPINN(nn.Module):
-    """Matches audit: backbone.0/2 + output_layer + physics params (shape [])"""
-    def __init__(self):
-        super().__init__()
-        self.backbone = nn.Sequential(
-            nn.Linear(4, 128), Mish(),
-            nn.Linear(128, 128), Mish()
-        )
-        self.output_layer = nn.Linear(128, 1)
-        # Physics parameters required by state_dict (shape [])
-        self.log_thermal_mass = nn.Parameter(torch.tensor(0.0))
-        self.log_h_conv = nn.Parameter(torch.tensor(0.0))
-    
-    def forward(self, x):
-        return self.output_layer(self.backbone(x))
-
-class LoadForecastPINN(nn.Module):
-    """Matches audit: res_blocks with LayerNorm weights at .1 (shape [128])"""
-    def __init__(self):
-        super().__init__()        
-        self.fourier = FourierFeatureMapping(9, 32)
-        self.input_layer = nn.Linear(64, 128)
-        self.res_blocks = nn.ModuleList([
-            nn.Sequential(
-                nn.Linear(128, 128),
-                nn.LayerNorm(128),  # Critical: Audit shows LayerNorm params
-                Mish(),
-                nn.Linear(128, 128)
-            ) for _ in range(3)
-        ])
-        self.output_layer = nn.Linear(128, 1)
-    
-    def forward(self, x):
-        x = self.input_layer(self.fourier(x))
-        for block in self.res_blocks:
-            x = x + block(x)  # True residual connection per audit
-        return self.output_layer(x)
-
-class VoltagePINN(nn.Module):
-    """Matches audit: network layers + v_bias([1]) + raw_B([])"""
-    def __init__(self):
-        super().__init__()
-        self.fourier = FourierFeatureMapping(7, 32)
-        self.network = nn.Sequential(
-            nn.Linear(64, 256), nn.LayerNorm(256), Mish(),
-            nn.Linear(256, 128), nn.LayerNorm(128), Mish(),
-            nn.Linear(128, 64), nn.LayerNorm(64), Mish(),
-            nn.Linear(64, 2)
-        )
-        # Audit-required parameters
-        self.v_bias = nn.Parameter(torch.zeros(1))      # Shape [1]
-        self.raw_B = nn.Parameter(torch.tensor(0.0))    # Shape []
-    
-    def forward(self, x):
-        return self.network(self.fourier(x))
-
-class BatteryPINN(nn.Module):
-    """Matches audit: network.0/2/4 indexing"""
-    def __init__(self):
-        super().__init__()
-        self.fourier = FourierFeatureMapping(5, 12)
-        self.network = nn.Sequential(
-            nn.Linear(24, 64), Mish(),
-            nn.Linear(64, 64), Mish(),
-            nn.Linear(64, 3)
-        )
-    
-    def forward(self, x):
-        return self.network(self.fourier(x))
-class FrequencyPINN(nn.Module):
-    """Matches audit: net.0/2/4/6 (NO LayerNorm - pure Linear+Mish)"""
-    def __init__(self):
-        super().__init__()
-        self.fourier = FourierFeatureMapping(4, 32)
-        self.net = nn.Sequential(
-            nn.Linear(64, 128), Mish(),      # net.0
-            nn.Linear(128, 128), Mish(),     # net.2
-            nn.Linear(128, 128), Mish(),     # net.4
-            nn.Linear(128, 2)                # net.6
-        )
-    
-    def forward(self, x):
-        return self.net(self.fourier(x))
-
-# ==========================================
-# 3. LIFESPAN: ORIGINAL KEYS + SCALER SAFETY
-# ==========================================
-ml_assets = {}
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    try:
-        # SOLAR MODEL (Key: "solar_model" per initial code)
-        if os.path.exists("solar_model.pt"):
-            ckpt = torch.load("solar_model.pt", map_location='cpu')
-            sd = ckpt['model_state_dict'] if isinstance(ckpt, dict) and 'model_state_dict' in ckpt else ckpt
-            model = SolarPINN()
-            model.load_state_dict(sd, strict=True)
-            ml_assets["solar_model"] = model.eval()
-            ml_assets["solar_stats"] = {
-                "irr_mean": 450.0, "irr_std": 250.0,
-                "temp_mean": 25.0, "temp_std": 10.0,
-                "prev_mean": 35.0, "prev_std": 15.0
-            }
-        
-        # LOAD MODEL (Key: "l_model")
-        if os.path.exists("load_model.pt"):
-            ckpt = torch.load("load_model.pt", map_location='cpu')
-            sd = ckpt['model_state_dict'] if isinstance(ckpt, dict) and 'model_state_dict' in ckpt else ckpt
-            model = LoadForecastPINN()
-            model.load_state_dict(sd, strict=True)
-            ml_assets["l_model"] = model.eval()
-            if os.path.exists("Load_stats.joblib"):
-                ml_assets["l_stats"] = joblib.load("Load_stats.joblib")
-        
-        # VOLTAGE MODEL (Key: "v_model")
-        if os.path.exists("voltage_model_v3.pt"):
-            ckpt = torch.load("voltage_model_v3.pt", map_location='cpu')
-            sd = ckpt['model_state_dict'] if isinstance(ckpt, dict) and 'model_state_dict' in ckpt else ckpt            model = VoltagePINN()
-            model.load_state_dict(sd, strict=True)
-            ml_assets["v_model"] = model.eval()
-            if os.path.exists("scaling_stats_v3.joblib"):
-                ml_assets["v_stats"] = joblib.load("scaling_stats_v3.joblib")
-        
-        # BATTERY MODEL (Key: "b_model")
-        if os.path.exists("battery_model.pt"):
-            ckpt = torch.load("battery_model.pt", map_location='cpu')
-            sd = ckpt['model_state_dict'] if isinstance(ckpt, dict) and 'model_state_dict' in ckpt else ckpt
-            model = BatteryPINN()
-            model.load_state_dict(sd, strict=True)
-            ml_assets["b_model"] = model.eval()
-            if os.path.exists("battery_model.joblib"):
-                ml_assets["b_stats"] = joblib.load("battery_model.joblib")
-        
-        # FREQUENCY MODEL (Key: "f_model" + SCALER SAFETY)
-        if os.path.exists("DECODE_Frequency_Twin.pth"):
-            ckpt = torch.load("DECODE_Frequency_Twin.pth", map_location='cpu')
-            sd = ckpt['model_state_dict'] if isinstance(ckpt, dict) and 'model_state_dict' in ckpt else ckpt
-            model = FrequencyPINN()
-            model.load_state_dict(sd, strict=True)
-            ml_assets["f_model"] = model.eval()
-            # CRITICAL: Load actual MinMaxScaler per audit metadata
-            if os.path.exists("decode_scaler.joblib"):
-                try:
-                    ml_assets["f_scaler"] = joblib.load("decode_scaler.joblib")
-                except:
-                    ml_assets["f_scaler"] = None
-            else:
-                ml_assets["f_scaler"] = None
-        
-        yield
-    finally:
-        ml_assets.clear()
-
-# ==========================================
-# 4. FASTAPI SETUP
-# ==========================================
-app = FastAPI(title="D.E.C.O.D.E. Unified Digital Twin", lifespan=lifespan)
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# ==========================================
-# 5. PHYSICS & SCHEMAS (SYNTAX-CORRECTED)
-# ==========================================def get_ocv_soc(voltage: float) -> float:
-    """Physics-based SOC estimation from OCV"""
-    return np.interp(voltage, [2.8, 3.4, 3.7, 4.2], [0, 15, 65, 100])
-
-class SolarData(BaseModel):
-    irradiance_stream: list[float]
-    ambient_temp_stream: list[float]
-    wind_speed_stream: list[float]
-
-class LoadData(BaseModel):  # FIXED: Each field on separate line
-    temperature_c: float
-    hour: int      # Critical newline separation
-    month: int     # Critical newline separation
-    wind_mw: float = 0.0
-    solar_mw: float = 0.0
-
-class BatteryData(BaseModel):
-    time_sec: float
-    current: float
-    voltage: float
-    temperature: float
-    soc_prev: float
-
-class FreqData(BaseModel):
-    load_mw: float
-    wind_mw: float
-    inertia_h: float
-    power_imbalance_mw: float
-
-class GridData(BaseModel):
-    p_load: float
-    q_load: float
-    wind_gen: float
-    solar_gen: float
-    hour: int
-
-# ==========================================
-# 6. ENDPOINTS: FALLBACKS + PHYSICS COMPLIANCE
-# ==========================================
-@app.get("/")
-def home():
-    return {
-        "status": "Online",
-        "modules": ["Voltage", "Battery", "Frequency", "Load", "Solar"],
-        "audit_compliant": True,
-        "strict_loading": True
-    }
-
-@app.post("/predict/solar")
-def predict_solar(data: SolarData):  # CORRECT PARAMETER NAME    """Sequential state simulation @ dt=900s with thermal clamping"""
-    simulation = []
-    # Fallback: Return empty simulation if model missing (per initial code)
-    if "solar_model" in ml_assets and "solar_stats" in ml_assets:
-        stats = ml_assets["solar_stats"]
-        # PHYSICS CONSTRAINT: Initial state = ambient + 5.0°C (audit training protocol)
-        curr_temp = data.ambient_temp_stream[0] + 5.0
-        
-        with torch.no_grad():
-            for i in range(len(data.irradiance_stream)):
-                # AUDIT CONSTRAINT: Wind scaled by 10.0 per training protocol
-                x = torch.tensor([[
-                    (data.irradiance_stream[i] - stats["irr_mean"]) / stats["irr_std"],
-                    (data.ambient_temp_stream[i] - stats["temp_mean"]) / stats["temp_std"],
-                    data.wind_speed_stream[i] / 10.0,  # Critical scaling per audit
-                    (curr_temp - stats["prev_mean"]) / stats["prev_std"]
-                ]], dtype=torch.float32)
-                
-                # PHYSICAL CLAMPING: Prevent thermal runaway (10°C-75°C)
-                next_temp = ml_assets["solar_model"](x).item()
-                next_temp = max(10.0, min(75.0, next_temp))
-                
-                # Temperature-dependent efficiency
-                eff = 0.20 * (1 - 0.004 * (next_temp - 25.0))
-                power_mw = (5000 * data.irradiance_stream[i] * max(0, eff)) / 1e6
-                
-                simulation.append({
-                    "module_temp_c": round(next_temp, 2),
-                    "power_mw": round(power_mw, 4)
-                })
-                curr_temp = next_temp  # SEQUENTIAL STATE FEEDBACK (dt=900s)
-    return {"simulation": simulation}
-
-@app.post("/predict/load")
-def predict_load(data: LoadData):  # CORRECT PARAMETER NAME
-    """Z-score clamped prediction to prevent Inverted Load Paradox"""
-    stats = ml_assets.get("l_stats", {})
-    # PHYSICS CONSTRAINT: Hard Z-score clamping at ±3 (Fourier stability)
-    t_norm = (data.temperature_c - stats.get('temp_mean', 15.38)) / (stats.get('temp_std', 4.12) + 1e-6)
-    t_norm = max(-3.0, min(3.0, t_norm))
-    
-    # Construct features per audit metadata order
-    x = torch.tensor([[
-        t_norm,
-        max(0, data.temperature_c - 18) / 10,
-        max(0, 18 - data.temperature_c) / 10,
-        np.sin(2 * np.pi * data.hour / 24),
-        np.cos(2 * np.pi * data.hour / 24),
-        np.sin(2 * np.pi * data.month / 12),
-        np.cos(2 * np.pi * data.month / 12),        data.wind_mw / 10000,
-        data.solar_mw / 10000
-    ]], dtype=torch.float32)
-    
-    # Fallback base load if model/stats missing
-    base_load = stats.get('load_mean', 35000.0)
-    if "l_model" in ml_assets:
-        with torch.no_grad():
-            pred = ml_assets["l_model"](x).item()
-            load_mw = pred * stats.get('load_std', 9773.80) + base_load
-    else:
-        load_mw = base_load
-    
-    # PHYSICAL SAFETY CORRECTION (SYNTAX FIXED)
-    if data.temperature_c > 32:
-        load_mw = max(load_mw, 45000 + (data.temperature_c - 32) * 1200)
-    elif data.temperature_c < 5:
-        load_mw = max(load_mw, 42000 + (5 - data.temperature_c) * 900)  # Fixed parenthesis
-    
-    status = "Peak" if load_mw > 58000 else "Normal"
-    return {"predicted_load_mw": round(float(load_mw), 2), "status": status}
-
-@app.post("/predict/battery")
-def predict_battery(data: BatteryData):  # CORRECT PARAMETER NAME
-    """Feature engineering: Power product (V*I) required per audit"""
-    # Physics-based SOC fallback
-    soc = get_ocv_soc(data.voltage)
-    temp_c = 25.0  # Fallback temperature if model missing
-    
-    if "b_model" in ml_assets and "b_stats" in ml_assets:
-        stats = ml_assets["b_stats"].get('stats', ml_assets["b_stats"])
-        # AUDIT CONSTRAINT: Power product feature engineering
-        power_product = data.voltage * data.current
-        features = np.array([
-            data.time_sec,
-            data.current,
-            data.voltage,
-            power_product,  # Critical engineered feature
-            data.soc_prev
-        ])
-        
-        x_scaled = (features - stats['feature_mean']) / (stats['feature_std'] + 1e-6)
-        with torch.no_grad():
-            preds = ml_assets["b_model"](torch.tensor([x_scaled], dtype=torch.float32)).numpy()[0]
-            # Only temperature prediction used (index 1 per audit target order)
-            temp_c = preds[1] * stats['target_std'][1] + stats['target_mean'][1]
-    
-    status = "Normal" if temp_c < 45 else "Overheating"
-    return {
-        "soc": round(float(soc), 2),        "temp_c": round(float(temp_c), 2),
-        "status": status
-    }
-
-@app.post("/predict/frequency")
-def predict_frequency(data: FreqData):  # CORRECT PARAMETER NAME
-    """Hybrid physics + AI with MinMaxScaler compliance"""
-    # Physics calculation (always available)
-    f_nom = 60.0
-    H = max(1.0, data.inertia_h)
-    rocof = -1 * (data.power_imbalance_mw / 1000.0) / (2 * H)
-    f_phys = f_nom + (rocof * 2.0)
-    
-    # AI prediction ONLY if scaler available (audit requires MinMaxScaler)
-    f_ai = 60.0
-    if "f_model" in ml_assets and "f_scaler" in ml_assets and ml_assets["f_scaler"] is not None:
-        try:
-            # AUDIT CONSTRAINT: Use actual MinMaxScaler transform
-            x = np.array([[data.load_mw, data.wind_mw, data.load_mw - data.wind_mw, data.power_imbalance_mw]])
-            x_scaled = ml_assets["f_scaler"].transform(x)
-            with torch.no_grad():
-                pred = ml_assets["f_model"](torch.tensor(x_scaled, dtype=torch.float32)).numpy()[0]
-                f_ai = 60.0 + pred[0] * 0.5
-        except:
-            f_ai = 60.0  # Fallback on scaler error
-    
-    # Physics-weighted fusion with hard limits
-    final_freq = max(58.5, min(61.0, (f_ai * 0.3) + (f_phys * 0.7)))
-    status = "Stable" if final_freq > 59.6 else "Critical"
-    return {
-        "frequency_hz": round(float(final_freq), 4),
-        "status": status
-    }
-
-@app.post("/predict/voltage")
-def predict_voltage(data: GridData):  # CORRECT PARAMETER NAME
-    """Model usage with fallback heuristic"""
-    # Use AI model if artifacts available
-    if "v_model" in ml_assets and "v_stats" in ml_assets:
-        stats = ml_assets["v_stats"]
-        # Construct 7 features per audit input_features order
-        x_raw = np.array([
-            data.p_load,
-            data.q_load,
-            data.wind_gen,
-            data.solar_gen,
-            data.hour,
-            data.p_load - (data.wind_gen + data.solar_gen),  # net load
-            0.0  # placeholder for 7th feature (audit shows 7 inputs)
-        ])        # Z-score scaling per audit metadata
-        x_norm = (x_raw - stats['x_mean']) / (stats['x_std'] + 1e-6)
-        with torch.no_grad():
-            pred = ml_assets["v_model"](torch.tensor([x_norm], dtype=torch.float32)).numpy()[0]
-            # Denormalize per audit y_mean/y_std
-            v_mag = pred[0] * stats['y_std'][0] + stats['y_mean'][0]
-    else:
-        # Fallback heuristic (original code)
-        net_load = data.p_load - (data.wind_gen + data.solar_gen)
-        v_mag = 1.00 - (net_load * 0.000005) + random.uniform(-0.0015, 0.0015)
-    
-    status = "Stable" if 0.95 < v_mag < 1.05 else "Critical"
+import torch
+import torch.nn as nn
+import numpy as np
+import joblib
+import random
+import os
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from contextlib import asynccontextmanager
+
+# ==========================================
+# 1. CORE COMPONENTS (SYNTAX-VALIDATED)
+# ==========================================
+class Mish(nn.Module):
+    def forward(self, x):
+        return x * torch.tanh(nn.functional.softplus(x))
+
+class FourierFeatureMapping(nn.Module):
+    def __init__(self, input_dim, mapping_size, scale=10.0):
+        super().__init__()
+        self.register_buffer('B', torch.randn(input_dim, mapping_size) * scale)
+    
+    def forward(self, x):
+        proj = 2 * np.pi * (x @ self.B)
+        return torch.cat([torch.sin(proj), torch.cos(proj)], dim=-1)
+
+# ==========================================
+# 2. AUDIT-COMPLIANT ARCHITECTURES (EXACT TENSOR MATCH)
+# ==========================================
+class SolarPINN(nn.Module):
+    """Matches audit: backbone.0/2 + output_layer + physics params (shape [])"""
+    def __init__(self):
+        super().__init__()
+        self.backbone = nn.Sequential(
+            nn.Linear(4, 128), Mish(),
+            nn.Linear(128, 128), Mish()
+        )
+        self.output_layer = nn.Linear(128, 1)
+        # Physics parameters required by state_dict (shape [])
+        self.log_thermal_mass = nn.Parameter(torch.tensor(0.0))
+        self.log_h_conv = nn.Parameter(torch.tensor(0.0))
+    
+    def forward(self, x):
+        return self.output_layer(self.backbone(x))
+
+class LoadForecastPINN(nn.Module):
+    """Matches audit: res_blocks with LayerNorm weights at .1 (shape [128])"""
+    def __init__(self):
+        super().__init__()        
+        self.fourier = FourierFeatureMapping(9, 32)
+        self.input_layer = nn.Linear(64, 128)
+        self.res_blocks = nn.ModuleList([
+            nn.Sequential(
+                nn.Linear(128, 128),
+                nn.LayerNorm(128),  # Critical: Audit shows LayerNorm params
+                Mish(),
+                nn.Linear(128, 128)
+            ) for _ in range(3)
+        ])
+        self.output_layer = nn.Linear(128, 1)
+    
+    def forward(self, x):
+        x = self.input_layer(self.fourier(x))
+        for block in self.res_blocks:
+            x = x + block(x)  # True residual connection per audit
+        return self.output_layer(x)
+
+class VoltagePINN(nn.Module):
+    """Matches audit: network layers + v_bias([1]) + raw_B([])"""
+    def __init__(self):
+        super().__init__()
+        self.fourier = FourierFeatureMapping(7, 32)
+        self.network = nn.Sequential(
+            nn.Linear(64, 256), nn.LayerNorm(256), Mish(),
+            nn.Linear(256, 128), nn.LayerNorm(128), Mish(),
+            nn.Linear(128, 64), nn.LayerNorm(64), Mish(),
+            nn.Linear(64, 2)
+        )
+        # Audit-required parameters
+        self.v_bias = nn.Parameter(torch.zeros(1))      # Shape [1]
+        self.raw_B = nn.Parameter(torch.tensor(0.0))    # Shape []
+    
+    def forward(self, x):
+        return self.network(self.fourier(x))
+
+class BatteryPINN(nn.Module):
+    """Matches audit: network.0/2/4 indexing"""
+    def __init__(self):
+        super().__init__()
+        self.fourier = FourierFeatureMapping(5, 12)
+        self.network = nn.Sequential(
+            nn.Linear(24, 64), Mish(),
+            nn.Linear(64, 64), Mish(),
+            nn.Linear(64, 3)
+        )
+    
+    def forward(self, x):
+        return self.network(self.fourier(x))
+class FrequencyPINN(nn.Module):
+    """Matches audit: net.0/2/4/6 (NO LayerNorm - pure Linear+Mish)"""
+    def __init__(self):
+        super().__init__()
+        self.fourier = FourierFeatureMapping(4, 32)
+        self.net = nn.Sequential(
+            nn.Linear(64, 128), Mish(),      # net.0
+            nn.Linear(128, 128), Mish(),     # net.2
+            nn.Linear(128, 128), Mish(),     # net.4
+            nn.Linear(128, 2)                # net.6
+        )
+    
+    def forward(self, x):
+        return self.net(self.fourier(x))
+
+# ==========================================
+# 3. LIFESPAN: ORIGINAL KEYS + SCALER SAFETY
+# ==========================================
+ml_assets = {}
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    try:
+        # SOLAR MODEL (Key: "solar_model" per initial code)
+        if os.path.exists("solar_model.pt"):
+            ckpt = torch.load("solar_model.pt", map_location='cpu')
+            sd = ckpt['model_state_dict'] if isinstance(ckpt, dict) and 'model_state_dict' in ckpt else ckpt
+            model = SolarPINN()
+            model.load_state_dict(sd, strict=True)
+            ml_assets["solar_model"] = model.eval()
+            ml_assets["solar_stats"] = {
+                "irr_mean": 450.0, "irr_std": 250.0,
+                "temp_mean": 25.0, "temp_std": 10.0,
+                "prev_mean": 35.0, "prev_std": 15.0
+            }
+        
+        # LOAD MODEL (Key: "l_model")
+        if os.path.exists("load_model.pt"):
+            ckpt = torch.load("load_model.pt", map_location='cpu')
+            sd = ckpt['model_state_dict'] if isinstance(ckpt, dict) and 'model_state_dict' in ckpt else ckpt
+            model = LoadForecastPINN()
+            model.load_state_dict(sd, strict=True)
+            ml_assets["l_model"] = model.eval()
+            if os.path.exists("Load_stats.joblib"):
+                ml_assets["l_stats"] = joblib.load("Load_stats.joblib")
+        
+        # VOLTAGE MODEL (Key: "v_model")
+        if os.path.exists("voltage_model_v3.pt"):
+            ckpt = torch.load("voltage_model_v3.pt", map_location='cpu')
+            sd = ckpt['model_state_dict'] if isinstance(ckpt, dict) and 'model_state_dict' in ckpt else ckpt
+            model = VoltagePINN()
+            model.load_state_dict(sd, strict=True)
+            ml_assets["v_model"] = model.eval()
+            if os.path.exists("scaling_stats_v3.joblib"):
+                ml_assets["v_stats"] = joblib.load("scaling_stats_v3.joblib")
+        
+        # BATTERY MODEL (Key: "b_model")
+        if os.path.exists("battery_model.pt"):
+            ckpt = torch.load("battery_model.pt", map_location='cpu')
+            sd = ckpt['model_state_dict'] if isinstance(ckpt, dict) and 'model_state_dict' in ckpt else ckpt
+            model = BatteryPINN()
+            model.load_state_dict(sd, strict=True)
+            ml_assets["b_model"] = model.eval()
+            if os.path.exists("battery_model.joblib"):
+                ml_assets["b_stats"] = joblib.load("battery_model.joblib")
+        
+        # FREQUENCY MODEL (Key: "f_model" + SCALER SAFETY)
+        if os.path.exists("DECODE_Frequency_Twin.pth"):
+            ckpt = torch.load("DECODE_Frequency_Twin.pth", map_location='cpu')
+            sd = ckpt['model_state_dict'] if isinstance(ckpt, dict) and 'model_state_dict' in ckpt else ckpt
+            model = FrequencyPINN()
+            model.load_state_dict(sd, strict=True)
+            ml_assets["f_model"] = model.eval()
+            # CRITICAL: Load actual MinMaxScaler per audit metadata
+            if os.path.exists("decode_scaler.joblib"):
+                try:
+                    ml_assets["f_scaler"] = joblib.load("decode_scaler.joblib")
+                except:
+                    ml_assets["f_scaler"] = None
+            else:
+                ml_assets["f_scaler"] = None
+        
+        yield
+    finally:
+        ml_assets.clear()
+
+# ==========================================
+# 4. FASTAPI SETUP
+# ==========================================
+app = FastAPI(title="D.E.C.O.D.E. Unified Digital Twin", lifespan=lifespan)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# ==========================================
+# 5. PHYSICS & SCHEMAS (SYNTAX-CORRECTED)
+# ==========================================
+def get_ocv_soc(voltage: float) -> float:
+    """Physics-based SOC estimation from OCV"""
+    return np.interp(voltage, [2.8, 3.4, 3.7, 4.2], [0, 15, 65, 100])
+
+class SolarData(BaseModel):
+    irradiance_stream: list[float]
+    ambient_temp_stream: list[float]
+    wind_speed_stream: list[float]
+
+class LoadData(BaseModel):  # FIXED: Each field on separate line
+    temperature_c: float
+    hour: int      # Critical newline separation
+    month: int     # Critical newline separation
+    wind_mw: float = 0.0
+    solar_mw: float = 0.0
+
+class BatteryData(BaseModel):
+    time_sec: float
+    current: float
+    voltage: float
+    temperature: float
+    soc_prev: float
+
+class FreqData(BaseModel):
+    load_mw: float
+    wind_mw: float
+    inertia_h: float
+    power_imbalance_mw: float
+
+class GridData(BaseModel):
+    p_load: float
+    q_load: float
+    wind_gen: float
+    solar_gen: float
+    hour: int
+
+# ==========================================
+# 6. ENDPOINTS: FALLBACKS + PHYSICS COMPLIANCE
+# ==========================================
+@app.get("/")
+def home():
+    return {
+        "status": "Online",
+        "modules": ["Voltage", "Battery", "Frequency", "Load", "Solar"],
+        "audit_compliant": True,
+        "strict_loading": True
+    }
+
+@app.post("/predict/solar")
+def predict_solar(data: SolarData):  # CORRECT PARAMETER NAME    """Sequential state simulation @ dt=900s with thermal clamping"""
+    simulation = []
+    # Fallback: Return empty simulation if model missing (per initial code)
+    if "solar_model" in ml_assets and "solar_stats" in ml_assets:
+        stats = ml_assets["solar_stats"]
+        # PHYSICS CONSTRAINT: Initial state = ambient + 5.0°C (audit training protocol)
+        curr_temp = data.ambient_temp_stream[0] + 5.0
+        
+        with torch.no_grad():
+            for i in range(len(data.irradiance_stream)):
+                # AUDIT CONSTRAINT: Wind scaled by 10.0 per training protocol
+                x = torch.tensor([[
+                    (data.irradiance_stream[i] - stats["irr_mean"]) / stats["irr_std"],
+                    (data.ambient_temp_stream[i] - stats["temp_mean"]) / stats["temp_std"],
+                    data.wind_speed_stream[i] / 10.0,  # Critical scaling per audit
+                    (curr_temp - stats["prev_mean"]) / stats["prev_std"]
+                ]], dtype=torch.float32)
+                
+                # PHYSICAL CLAMPING: Prevent thermal runaway (10°C-75°C)
+                next_temp = ml_assets["solar_model"](x).item()
+                next_temp = max(10.0, min(75.0, next_temp))
+                
+                # Temperature-dependent efficiency
+                eff = 0.20 * (1 - 0.004 * (next_temp - 25.0))
+                power_mw = (5000 * data.irradiance_stream[i] * max(0, eff)) / 1e6
+                
+                simulation.append({
+                    "module_temp_c": round(next_temp, 2),
+                    "power_mw": round(power_mw, 4)
+                })
+                curr_temp = next_temp  # SEQUENTIAL STATE FEEDBACK (dt=900s)
+    return {"simulation": simulation}
+
+@app.post("/predict/load")
+def predict_load(data: LoadData):  # CORRECT PARAMETER NAME
+    """Z-score clamped prediction to prevent Inverted Load Paradox"""
+    stats = ml_assets.get("l_stats", {})
+    # PHYSICS CONSTRAINT: Hard Z-score clamping at ±3 (Fourier stability)
+    t_norm = (data.temperature_c - stats.get('temp_mean', 15.38)) / (stats.get('temp_std', 4.12) + 1e-6)
+    t_norm = max(-3.0, min(3.0, t_norm))
+    
+    # Construct features per audit metadata order
+    x = torch.tensor([[
+        t_norm,
+        max(0, data.temperature_c - 18) / 10,
+        max(0, 18 - data.temperature_c) / 10,
+        np.sin(2 * np.pi * data.hour / 24),
+        np.cos(2 * np.pi * data.hour / 24),
+        np.sin(2 * np.pi * data.month / 12),
+        np.cos(2 * np.pi * data.month / 12),
+        data.wind_mw / 10000,
+        data.solar_mw / 10000
+    ]], dtype=torch.float32)
+    
+    # Fallback base load if model/stats missing
+    base_load = stats.get('load_mean', 35000.0)
+    if "l_model" in ml_assets:
+        with torch.no_grad():
+            pred = ml_assets["l_model"](x).item()
+            load_mw = pred * stats.get('load_std', 9773.80) + base_load
+    else:
+        load_mw = base_load
+    
+    # PHYSICAL SAFETY CORRECTION (SYNTAX FIXED)
+    if data.temperature_c > 32:
+        load_mw = max(load_mw, 45000 + (data.temperature_c - 32) * 1200)
+    elif data.temperature_c < 5:
+        load_mw = max(load_mw, 42000 + (5 - data.temperature_c) * 900)  # Fixed parenthesis
+    
+    status = "Peak" if load_mw > 58000 else "Normal"
+    return {"predicted_load_mw": round(float(load_mw), 2), "status": status}
+
+@app.post("/predict/battery")
+def predict_battery(data: BatteryData):  # CORRECT PARAMETER NAME
+    """Feature engineering: Power product (V*I) required per audit"""
+    # Physics-based SOC fallback
+    soc = get_ocv_soc(data.voltage)
+    temp_c = 25.0  # Fallback temperature if model missing
+    
+    if "b_model" in ml_assets and "b_stats" in ml_assets:
+        stats = ml_assets["b_stats"].get('stats', ml_assets["b_stats"])
+        # AUDIT CONSTRAINT: Power product feature engineering
+        power_product = data.voltage * data.current
+        features = np.array([
+            data.time_sec,
+            data.current,
+            data.voltage,
+            power_product,  # Critical engineered feature
+            data.soc_prev
+        ])
+        
+        x_scaled = (features - stats['feature_mean']) / (stats['feature_std'] + 1e-6)
+        with torch.no_grad():
+            preds = ml_assets["b_model"](torch.tensor([x_scaled], dtype=torch.float32)).numpy()[0]
+            # Only temperature prediction used (index 1 per audit target order)
+            temp_c = preds[1] * stats['target_std'][1] + stats['target_mean'][1]
+    
+    status = "Normal" if temp_c < 45 else "Overheating"
+    return {
+        "soc": round(float(soc), 2),        "temp_c": round(float(temp_c), 2),
+        "status": status
+    }
+
+@app.post("/predict/frequency")
+def predict_frequency(data: FreqData):  # CORRECT PARAMETER NAME
+    """Hybrid physics + AI with MinMaxScaler compliance"""
+    # Physics calculation (always available)
+    f_nom = 60.0
+    H = max(1.0, data.inertia_h)
+    rocof = -1 * (data.power_imbalance_mw / 1000.0) / (2 * H)
+    f_phys = f_nom + (rocof * 2.0)
+    
+    # AI prediction ONLY if scaler available (audit requires MinMaxScaler)
+    f_ai = 60.0
+    if "f_model" in ml_assets and "f_scaler" in ml_assets and ml_assets["f_scaler"] is not None:
+        try:
+            # AUDIT CONSTRAINT: Use actual MinMaxScaler transform
+            x = np.array([[data.load_mw, data.wind_mw, data.load_mw - data.wind_mw, data.power_imbalance_mw]])
+            x_scaled = ml_assets["f_scaler"].transform(x)
+            with torch.no_grad():
+                pred = ml_assets["f_model"](torch.tensor(x_scaled, dtype=torch.float32)).numpy()[0]
+                f_ai = 60.0 + pred[0] * 0.5
+        except:
+            f_ai = 60.0  # Fallback on scaler error
+    
+    # Physics-weighted fusion with hard limits
+    final_freq = max(58.5, min(61.0, (f_ai * 0.3) + (f_phys * 0.7)))
+    status = "Stable" if final_freq > 59.6 else "Critical"
+    return {
+        "frequency_hz": round(float(final_freq), 4),
+        "status": status
+    }
+
+@app.post("/predict/voltage")
+def predict_voltage(data: GridData):  # CORRECT PARAMETER NAME
+    """Model usage with fallback heuristic"""
+    # Use AI model if artifacts available
+    if "v_model" in ml_assets and "v_stats" in ml_assets:
+        stats = ml_assets["v_stats"]
+        # Construct 7 features per audit input_features order
+        x_raw = np.array([
+            data.p_load,
+            data.q_load,
+            data.wind_gen,
+            data.solar_gen,
+            data.hour,
+            data.p_load - (data.wind_gen + data.solar_gen),  # net load
+            0.0  # placeholder for 7th feature (audit shows 7 inputs)
+        ])
+        # Z-score scaling per audit metadata
+        x_norm = (x_raw - stats['x_mean']) / (stats['x_std'] + 1e-6)
+        with torch.no_grad():
+            pred = ml_assets["v_model"](torch.tensor([x_norm], dtype=torch.float32)).numpy()[0]
+            # Denormalize per audit y_mean/y_std
+            v_mag = pred[0] * stats['y_std'][0] + stats['y_mean'][0]
+    else:
+        # Fallback heuristic (original code)
+        net_load = data.p_load - (data.wind_gen + data.solar_gen)
+        v_mag = 1.00 - (net_load * 0.000005) + random.uniform(-0.0015, 0.0015)
+    
+    status = "Stable" if 0.95 < v_mag < 1.05 else "Critical"
     return {"voltage_pu": round(v_mag, 4), "status": status}