Create infra.py

infra.py

@@ -0,0 +1,124 @@
+import os
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+import pandas as pd
+from safetensors.torch import load_file
+from typing import List, Tuple, Optional
+
+class ServiceConfig:
+    MODEL_PATH = os.path.join(os.path.abspath(os.getcwd()), "lpr_oracle_ensemble.safetensors")
+    DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'
+    NUM_MODELS = 5
+    LOOKBACK_DAYS = 60
+    DECISION_THRESHOLD = 0.9957 
+    IN_CHANNELS = 2
+
+class InceptionModule(nn.Module):
+    def __init__(self, in_channels: int, out_channels: int, kernel_sizes=[9, 19, 39], bottleneck_channels=32):
+        super().__init__()
+        self.use_bottleneck = in_channels > 1
+        if self.use_bottleneck:
+            self.bottleneck = nn.Conv1d(in_channels, bottleneck_channels, kernel_size=1, bias=False)
+            in_channels = bottleneck_channels
+        self.conv_layers = nn.ModuleList()
+        for k in kernel_sizes:
+            self.conv_layers.append(nn.Conv1d(in_channels, out_channels, kernel_size=k, padding=k//2, bias=False))
+        self.maxpool = nn.MaxPool1d(kernel_size=3, stride=1, padding=1)
+        self.conv_pool = nn.Conv1d(in_channels, out_channels, kernel_size=1, bias=False)
+        self.bn = nn.BatchNorm1d(out_channels * (len(kernel_sizes) + 1))
+        self.act = nn.ReLU()
+
+    def forward(self, x):
+        input_tensor = x
+        if self.use_bottleneck: x = self.bottleneck(x)
+        outputs = [layer(x)[:, :, :input_tensor.shape[2]] for layer in self.conv_layers]
+        pool_out = self.conv_pool(self.maxpool(x))[:, :, :input_tensor.shape[2]]
+        outputs.append(pool_out)
+        return self.act(self.bn(torch.cat(outputs, dim=1)))
+
+class InceptionTimeNet(nn.Module):
+    def __init__(self, in_channels=2, num_classes=1):
+        super().__init__()
+        self.block1 = InceptionModule(in_channels, 32)
+        self.block2 = InceptionModule(32 * 4, 32)
+        self.shortcut = nn.Conv1d(in_channels, 32 * 4, kernel_size=1, bias=False)
+        self.bn_sc = nn.BatchNorm1d(32 * 4)
+        self.gap = nn.AdaptiveAvgPool1d(1)
+        self.fc = nn.Linear(32 * 4, num_classes)
+        
+    def forward(self, x):
+        x = x.permute(0, 2, 1)
+        res = self.bn_sc(self.shortcut(x))
+        out = self.block2(self.block1(x))
+        out = F.relu(out + res)
+        return self.fc(self.gap(out).squeeze(-1))
+
+class LPROracleService:
+    def __init__(self, model_path: str = ServiceConfig.MODEL_PATH):
+        self.device = ServiceConfig.DEVICE
+        self.models = self._load_ensemble(model_path)
+        print(f"LPR-Oracle Service Online. Device: {self.device}. Threshold: {ServiceConfig.DECISION_THRESHOLD}")
+
+    def _load_ensemble(self, path: str) -> List[nn.Module]:
+        if not os.path.exists(path):
+            raise FileNotFoundError(f"Weights not found at {path}")
+            
+        print(f"Loading weights from {path}...")
+        full_state = load_file(path)
+        models = []
+        
+        for i in range(ServiceConfig.NUM_MODELS):
+            model = InceptionTimeNet(in_channels=ServiceConfig.IN_CHANNELS).to(self.device)
+            prefix = f"m{i}."
+            model_state = {k[len(prefix):]: v for k, v in full_state.items() if k.startswith(prefix)}
+            model.load_state_dict(model_state)
+            model.eval()
+            models.append(model)
+            
+        return models
+
+    def preprocess(self, sequence: np.ndarray) -> torch.Tensor:
+        if sequence.ndim == 2:
+            sequence = sequence[np.newaxis, ...]
+            
+        _, L, C = sequence.shape
+        if L != ServiceConfig.LOOKBACK_DAYS or C != ServiceConfig.IN_CHANNELS:
+            raise ValueError(f"Input shape mismatch. Expected (N, {ServiceConfig.LOOKBACK_DAYS}, {ServiceConfig.IN_CHANNELS}), got {sequence.shape}")
+
+        return torch.FloatTensor(sequence).to(self.device)
+
+    def predict(self, sequence: np.ndarray) -> dict:
+        x = self.preprocess(sequence)
+        ensemble_probs = []
+
+        with torch.no_grad():
+            for model in self.models:
+                logits = model(x)
+                probs = torch.sigmoid(logits).cpu().numpy()
+                probs = 1.0 - probs
+                ensemble_probs.append(probs)
+
+        avg_prob = np.mean(ensemble_probs, axis=0)
+        
+        is_change = avg_prob > ServiceConfig.DECISION_THRESHOLD
+        
+        return {
+            "probability": float(avg_prob[0]),
+            "threshold": ServiceConfig.DECISION_THRESHOLD,
+            "alert": bool(is_change[0])
+        }
+
+if __name__ == "__main__":
+    try:
+        service = LPROracleService()
+        
+        print("\nSimulating Incoming Data Stream")
+        
+        mock_data_stable = np.random.randn(60, 2) 
+        result_stable = service.predict(mock_data_stable)
+        print(f"Input: {result_stable}")
+        
+    except Exception as e:
+        print(f"Service Error: {e}")