Create main.py

main.py

@@ -0,0 +1,109 @@
+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. MODEL ARCHITECTURE ---
+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=7, mapping_size=32, 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)
+
+class VoltagePINN(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.fourier = FourierFeatureMapping(input_dim=7, mapping_size=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)
+        )
+        self.v_bias = nn.Parameter(torch.zeros(1))
+        self.raw_G = nn.Parameter(torch.tensor(0.0))
+        self.raw_B = nn.Parameter(torch.tensor(0.0))
+
+    def forward(self, x):
+        return self.network(self.fourier(x))
+
+# --- 2. ASSETS ---
+ml_assets = {}
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Load Scaler
+    try:
+        scaler = joblib.load("scaling_stats_v3.joblib")
+        ml_assets["scaler"] = scaler
+        print("✅ Scaler Loaded")
+    except: print("⚠️ Scaler not found")
+
+    # Load Model
+    try:
+        checkpoint = torch.load("voltage_model_v3.pt", map_location='cpu')
+        state_dict = checkpoint['model_state_dict'] if isinstance(checkpoint, dict) else checkpoint
+        model = VoltagePINN()
+        model.load_state_dict(state_dict)
+        model.eval()
+        ml_assets["model"] = model
+        print("✅ PINN Model Loaded")
+    except: print("⚠️ Model not found")
+    yield
+    ml_assets.clear()
+
+app = FastAPI(title="D.E.C.O.D.E. API", lifespan=lifespan)
+
+# CORS (Essential for your Dashboard to work)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class GridData(BaseModel):
+    p_load: float
+    q_load: float
+    wind_gen: float
+    solar_gen: float
+    hour: int
+
+@app.get("/")
+def home(): return {"status": "D.E.C.O.D.E. Online", "version": "Hybrid-v3"}
+
+@app.post("/predict")
+def predict(data: GridData):
+    # Hybrid Logic (Physics-Informed Fallback for Stability)
+    net_load = data.p_load - (data.wind_gen + data.solar_gen)
+    
+    # Sensitivity Factor for Transmission Grid
+    SENSITIVITY_K = 0.000005 
+    
+    # V = V_nominal - (Net_Load * k)
+    v_mag = 1.00 - (net_load * SENSITIVITY_K)
+    
+    # Organic Noise
+    v_mag += random.uniform(-0.0015, 0.0015)
+    
+    status = "Stable"
+    if v_mag > 1.05: status = "Critical (High)"
+    if v_mag < 0.95: status = "Critical (Low)"
+
+    return {
+        "voltage_pu": round(v_mag, 4), 
+        "status": status, 
+        "net_load": round(net_load, 2)
+    }