Update model.py

model.py

@@ -1,10 +1,47 @@
 import logging
 from typing import Dict, List
+import torch
+import torch.nn as nn
+import numpy as np
+import pickle
+from sklearn.preprocessing import StandardScaler
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
+# LSTM Model Definition (must match training script)
+class DelayPredictor(nn.Module):
+    def __init__(self, input_size, hidden_size, num_layers):
+        super(DelayPredictor, self).__init__()
+        self.hidden_size = hidden_size
+        self.num_layers = num_layers
+        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
+        self.attention = nn.Linear(hidden_size, 1)
+        self.fc = nn.Linear(hidden_size, 1)
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, x):
+        lstm_out, _ = self.lstm(x)
+        attn_weights = torch.softmax(self.attention(lstm_out).squeeze(-1), dim=1)
+        context = torch.bmm(attn_weights.unsqueeze(1), lstm_out).squeeze(1)
+        out = self.fc(context)
+        return self.sigmoid(out) * 100
+
+# Load model and scaler
+try:
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = DelayPredictor(input_size=7, hidden_size=64, num_layers=2).to(device)
+    model.load_state_dict(torch.load("models/delay_model.pth", map_location=device))
+    model.eval()
+    with open("models/scaler.pkl", "rb") as f:
+        scaler = pickle.load(f)
+    logger.info("LSTM model and scaler loaded successfully")
+except Exception as e:
+    logger.error(f"Failed to load model or scaler: {str(e)}")
+    model = None
+    scaler = None
+
 def get_weather_condition(score: int) -> str:
     """Map weather impact score (0-100) to descriptive weather condition."""
     if score <= 10:
@@ -36,7 +73,7 @@ def call_ai_model_for_insights(input_data: Dict, delay_risk: float) -> List[str]
     shift_hours = input_data.get("workforce_shift_hours", 0)
     weather_score = input_data.get("weather_impact_score", 0)
     weather_condition = input_data.get("weather_condition", get_weather_condition(weather_score))
-    city = input_data.get("city", "Unknown")
+    project_location = input_data.get("project_location", "Unknown")
 
     # Initialize insights with scores for prioritization
     insights = []
@@ -47,42 +84,42 @@ def call_ai_model_for_insights(input_data: Dict, delay_risk: float) -> List[str]
 
     # Delay risk-based insights
     if delay_risk > 75:
-        add_insight(f"Urgent: High delay risk detected for {phase}: {task} in {city}. Take immediate action.", 1.0)
+        add_insight(f"Urgent: High delay risk detected for {phase}: {task} in {project_location}. Take immediate action.", 1.0)
     elif delay_risk > 50:
-        add_insight(f"Monitor {phase}: {task} closely in {city} to prevent delays.", 0.9)
+        add_insight(f"Monitor {phase}: {task} closely in {project_location} to prevent delays.", 0.9)
     elif delay_risk > 25:
-        add_insight(f"Maintain steady progress for {phase}: {task} in {city}.", 0.7)
+        add_insight(f"Maintain steady progress for {phase}: {task} in {project_location}.", 0.7)
     else:
-        add_insight(f"Optimize resources for {phase}: {task} in {city} to maintain schedule.", 0.6)
+        add_insight(f"Optimize resources for {phase}: {task} in {project_location} to maintain schedule.", 0.6)
 
-    # Weather-specific insights (enhanced)
+    # Weather-specific insights
     if weather_score > 85:
-        add_insight(f"Critical: Severe storm forecast in {city} for {phase}: {task}. Consider halting outdoor activities.", 1.1)
+        add_insight(f"Critical: Severe storm forecast in {project_location} for {phase}: {task}. Consider halting outdoor activities.", 1.1)
     elif weather_score > 70:
-        add_insight(f"Reschedule outdoor tasks for {phase}: {task} in {city} due to heavy rain forecast.", 1.0)
+        add_insight(f"Reschedule outdoor tasks for {phase}: {task} in {project_location} due to heavy rain forecast.", 1.0)
     elif weather_score > 50:
-        add_insight(f"Shift to indoor or weather-resistant tasks for {phase}: {task} in {city} due to light rain.", 0.9)
+        add_insight(f"Shift to indoor or weather-resistant tasks for {phase}: {task} in {project_location} due to light rain.", 0.9)
     elif weather_score > 30:
-        add_insight(f"Monitor cloudy conditions in {city} for {phase}: {task} to avoid unexpected delays.", 0.7)
+        add_insight(f"Monitor cloudy conditions in {project_location} for {phase}: {task} to avoid unexpected delays.", 0.7)
     else:
-        add_insight(f"Proceed with {phase}: {task} in {city} under favorable weather conditions.", 0.6)
+        add_insight(f"Proceed with {phase}: {task} in {project_location} under favorable weather conditions.", 0.6)
 
     # Phase/task-specific insights
     task_specific = {
         "Planning": {
-            "Define Scope": f"Ensure stakeholder alignment for Planning: Define Scope in {city}, considering weather impacts.",
-            "Resource Allocation": f"Secure budget and resources early for Planning: Resource Allocation in {city}.",
-            "Permit Acquisition": f"Expedite permits for Planning: Permit Acquisition in {city} to avoid weather-related delays."
+            "Define Scope": f"Ensure stakeholder alignment for Planning: Define Scope in {project_location}, considering weather impacts.",
+            "Resource Allocation": f"Secure budget and resources early for Planning: Resource Allocation in {project_location}.",
+            "Permit Acquisition": f"Expedite permits for Planning: Permit Acquisition in {project_location} to avoid weather-related delays."
         },
         "Design": {
-            "Architectural Drafting": f"Engage architects early for Design: Architectural Drafting in {city}, accounting for weather.",
-            "Engineering Analysis": f"Hire additional engineers for Design: Engineering Analysis in {city} to meet deadlines.",
-            "Design Review": f"Schedule thorough reviews for Design: Design Review in {city}, considering forecast."
+            "Architectural Drafting": f"Engage architects early for Design: Architectural Drafting in {project_location}, accounting for weather.",
+            "Engineering Analysis": f"Hire additional engineers for Design: Engineering Analysis in {project_location} to meet deadlines.",
+            "Design Review": f"Schedule thorough reviews for Design: Design Review in {project_location}, considering forecast."
         },
         "Construction": {
-            "Foundation Work": f"Optimize material delivery for Construction: Foundation Work in {city}, avoiding {weather_condition.lower()}.",
-            "Structural Build": f"Ensure equipment availability for Construction: Structural Build in {city} under {weather_condition.lower()}.",
-            "Utility Installation": f"Coordinate subcontractors for Construction: Utility Installation in {city}, monitoring weather."
+            "Foundation Work": f"Optimize material delivery for Construction: Foundation Work in {project_location}, avoiding {weather_condition.lower()}.",
+            "Structural Build": f"Ensure equipment availability for Construction: Structural Build in {project_location} under {weather_condition.lower()}.",
+            "Utility Installation": f"Coordinate subcontractors for Construction: Utility Installation in {project_location}, monitoring weather."
         }
     }
     if phase in task_specific and task in task_specific[phase]:
@@ -90,139 +127,146 @@ def call_ai_model_for_insights(input_data: Dict, delay_risk: float) -> List[str]
 
     # Workforce-based insights
     if workforce_gap > 30:
-        add_insight(f"Urgently hire subcontractors in {city} to address {workforce_gap}% workforce shortage.", 1.0)
+        add_insight(f"Urgently hire subcontractors in {project_location} to address {workforce_gap}% workforce shortage.", 1.0)
     elif workforce_gap > 15:
-        add_insight(f"Recruit additional workers in {city} to reduce {workforce_gap}% workforce gap.", 0.9)
+        add_insight(f"Recruit additional workers in {project_location} to reduce {workforce_gap}% workforce gap.", 0.9)
     elif workforce_gap > 5:
-        add_insight(f"Consider temporary staff in {city} to address minor workforce gap.", 0.7)
+        add_insight(f"Consider temporary staff in {project_location} to address minor workforce gap.", 0.7)
 
     if skill_level == "low":
-        add_insight(f"Provide training in {city} to improve low skill levels for {phase}: {task}.", 0.9)
+        add_insight(f"Provide training in {project_location} to improve low skill levels for {phase}: {task}.", 0.9)
     elif skill_level == "medium" and delay_risk > 50:
-        add_insight(f"Upskill workforce in {city} for efficiency in {phase}: {task}.", 0.8)
+        add_insight(f"Upskill workforce in {project_location} for efficiency in {phase}: {task}.", 0.8)
     elif skill_level == "high" and delay_risk < 25:
-        add_insight(f"Leverage high skill levels in {city} to maintain {phase}: {task} progress.", 0.6)
+        add_insight(f"Leverage high skill levels in {project_location} to maintain {phase}: {task} progress.", 0.6)
 
     if shift_hours < 6:
-        add_insight(f"Extend shift hours beyond {shift_hours} in {city} to meet {phase}: {task} deadlines.", 0.9)
+        add_insight(f"Extend shift hours beyond {shift_hours} in {project_location} to meet {phase}: {task} deadlines.", 0.9)
     elif shift_hours < 8 and delay_risk > 50:
-        add_insight(f"Increase shift hours to 8 in {city} for {phase}: {task}.", 0.8)
+        add_insight(f"Increase shift hours to 8 in {project_location} for {phase}: {task}.", 0.8)
     elif shift_hours > 10:
-        add_insight(f"Balance shifts in {city} to prevent burnout during {phase}: {task}.", 0.7)
+        add_insight(f"Balance shifts in {project_location} to prevent burnout during {phase}: {task}.", 0.7)
 
     # Progress and duration-based insights
     if expected_duration > 0 and actual_duration > expected_duration:
         overrun_pct = ((actual_duration - expected_duration) / expected_duration) * 100
         if overrun_pct > 20:
-            add_insight(f"Address significant duration overrun ({overrun_pct:.1f}%) for {phase}: {task} in {city}.", 1.0)
+            add_insight(f"Address significant duration overrun ({overrun_pct:.1f}%) for {phase}: {task} in {project_location}.", 1.0)
         elif overrun_pct > 10:
-            add_insight(f"Review scheduling to address {overrun_pct:.1f}% overrun in {phase}: {task} in {city}.", 0.8)
+            add_insight(f"Review scheduling to address {overrun_pct:.1f}% overrun in {phase}: {task} in {project_location}.", 0.8)
 
     if expected_duration > 0:
         expected_progress = min((actual_duration / expected_duration) * 100, 100)
         if current_progress < expected_progress * 0.8:
-            add_insight(f"Accelerate task progress for {phase}: {task} in {city} to align with schedule.", 0.9)
+            add_insight(f"Accelerate task progress for {phase}: {task} in {project_location} to align with schedule.", 0.9)
         elif current_progress < 50 and delay_risk > 50:
-            add_insight(f"Increase resources to boost {current_progress}% progress in {phase}: {task} in {city}.", 0.8)
+            add_insight(f"Increase resources to boost {current_progress}% progress in {phase}: {task} in {project_location}.", 0.8)
 
     # Edge cases
     if workforce_gap >= 90:
-        add_insight(f"Critical: Halt non-essential tasks in {city} until workforce gap for {phase}: {task} is resolved.", 1.1)
+        add_insight(f"Critical: Halt non-essential tasks in {project_location} until workforce gap for {phase}: {task} is resolved.", 1.1)
     if current_progress == 0 and delay_risk > 50:
-        add_insight(f"Initiate {phase}: {task} in {city} immediately to avoid further delays.", 1.0)
+        add_insight(f"Initiate {phase}: {task} in {project_location} immediately to avoid further delays.", 1.0)
     if expected_duration == 0 or actual_duration == 0:
-        add_insight(f"Provide accurate duration estimates for {phase}: {task} in {city} for reliable predictions.", 0.7)
+        add_insight(f"Provide accurate duration estimates for {phase}: {task} in {project_location} for reliable predictions.", 0.7)
     if weather_score > 50 and phase == "Construction":
-        add_insight(f"Prepare contingency plans for {phase}: {task} in {city} due to adverse weather forecast.", 0.95)
+        add_insight(f"Prepare contingency plans for {phase}: {task} in {project_location} due to adverse weather forecast.", 0.95)
 
     # Sort insights by priority and select top 3-5
     insights.sort(key=lambda x: x[1], reverse=True)
     selected_insights = [insight[0] for insight in insights[:5]]
 
     logger.info(f"Generated insights: {selected_insights}")
-    return selected_insights or [f"No significant delay factors detected for {phase}: {task} in {city}."]
+    return selected_insights or [f"No significant delay factors detected for {phase}: {task} in {project_location}."]
 
 def predict_delay(input_data: Dict) -> Dict:
     """
-    Predict delay probability based on project task data.
-    Uses task duration, progress, workforce info, and weather impact.
-    Insights are generated using detailed hardcoded rules.
+    Predict delay probability using LSTM model.
+    Inputs: Project task data (phase, progress, duration, workforce, weather).
+    Outputs: Delay probability, AI insights, high-risk phases, weather condition.
     """
-    logger.info("Starting delay prediction")
+    logger.info("Starting LSTM delay prediction")
+    if model is None or scaler is None:
+        logger.error("Model or scaler not loaded; falling back to default")
+        return {
+            "project": input_data.get("project_name", "Unnamed Project"),
+            "phase": input_data.get("phase", ""),
+            "task": input_data.get("task", ""),
+            "delay_probability": 50.0,
+            "ai_insights": "Model unavailable; please check deployment.",
+            "high_risk_phases": [],
+            "weather_condition": "Unknown"
+        }
+
     phase = input_data.get("phase", "")
     task = input_data.get("task", "")
-    expected_duration = input_data.get("task_expected_duration", 0)
-    actual_duration = input_data.get("task_actual_duration", 0)
-    
-    current_progress = input_data.get("current_progress", 0)        # in %
-    workforce_gap_pct = input_data.get("workforce_gap", 0)          # in %
-    skill_level = input_data.get("workforce_skill_level", "").lower()
-    shift_hours = input_data.get("workforce_shift_hours", 0)
-    weather_score = input_data.get("weather_impact_score", 0)       # 0-100 scale
+    weather_condition = input_data.get("weather_condition", get_weather_condition(input_data.get("weather_impact_score", 0)))
+
+    # Prepare input features
+    phase_mapping = {"Planning": 0, "Design": 1, "Construction": 2}
+    skill_mapping = {"Low": 0, "Medium": 1, "High": 2}
+    try:
+        features = np.array([[
+            input_data.get("current_progress", 0),
+            input_data.get("task_expected_duration", 0),
+            input_data.get("task_actual_duration", 0),
+            input_data.get("workforce_gap", 0),
+            input_data.get("weather_impact_score", 0),
+            skill_mapping.get(input_data.get("workforce_skill_level", "Medium"), 1),
+            phase_mapping.get(phase, 0)
+        ]])
+    except KeyError as e:
+        logger.error(f"Invalid input data: {str(e)}")
+        return {
+            "project": input_data.get("project_name", "Unnamed Project"),
+            "phase": phase,
+            "task": task,
+            "delay_probability": 50.0,
+            "ai_insights": f"Invalid input: {str(e)}",
+            "high_risk_phases": [],
+            "weather_condition": weather_condition
+        }
+
+    # Standardize and reshape
+    try:
+        features_scaled = scaler.transform(features)
+        features_tensor = torch.tensor(features_scaled.reshape(1, 1, -1), dtype=torch.float32).to(device)
+    except Exception as e:
+        logger.error(f"Feature preprocessing failed: {str(e)}")
+        return {
+            "project": input_data.get("project_name", "Unnamed Project"),
+            "phase": phase,
+            "task": task,
+            "delay_probability": 50.0,
+            "ai_insights": f"Preprocessing error: {str(e)}",
+            "high_risk_phases": [],
+            "weather_condition": weather_condition
+        }
 
-    # Auto-set weather condition if missing or inconsistent
-    weather_condition = input_data.get("weather_condition", "")
-    if not weather_condition:
-        weather_condition = get_weather_condition(weather_score)
+    # Predict
+    with torch.no_grad():
+        delay_risk = model(features_tensor).cpu().numpy().item()
+        delay_risk = round(max(0, min(delay_risk, 100)), 1)
 
-    # Task options for phase (hardcoded to match app.py)
+    # Generate high_risk_phases
     task_options = {
         "Planning": ["Define Scope", "Resource Allocation", "Permit Acquisition"],
         "Design": ["Architectural Drafting", "Engineering Analysis", "Design Review"],
         "Construction": ["Foundation Work", "Structural Build", "Utility Installation"]
     }
-
-    delay_risk = 0
-
-    # 1. Duration overrun risk
-    if expected_duration > 0 and actual_duration > expected_duration:
-        overrun_pct = ((actual_duration - expected_duration) / expected_duration) * 100
-        delay_risk += min(overrun_pct, 30)
-
-    # 2. Progress lag risk
-    if expected_duration > 0 and current_progress >= 0:
-        expected_progress = (actual_duration / expected_duration) * 100
-        if current_progress < expected_progress:
-            progress_gap = expected_progress - current_progress
-            delay_risk += min(progress_gap, 25)
-
-    # 3. Workforce gap impact
-    if workforce_gap_pct > 0:
-        delay_risk += min(workforce_gap_pct * 0.5, 20)
-
-    # 4. Skill level effect
-    if skill_level == "low":
-        delay_risk += 15
-    elif skill_level == "medium":
-        delay_risk += 7
-
-    # 5. Shift hours effect
-    if shift_hours < 8:
-        delay_risk += (8 - shift_hours) * 3
-    elif shift_hours > 8:
-        delay_risk -= min((shift_hours - 8) * 2, 10)
-
-    # 6. Weather impact effect
-    if weather_score > 50:
-        delay_risk += min(weather_score / 2, 20)
-
-    # Ensure delay_risk is between 0 and 100
-    delay_risk = max(0, min(delay_risk, 100))
-
-    # Generate high_risk_phases for all tasks in the phase
     high_risk_phases = []
     if phase in task_options:
         for t in task_options[phase]:
             task_risk = delay_risk
             if t != task:
-                task_risk = min(max(task_risk + (hash(t) % 10 - 5), 0), 100)  # ±5% variation
+                task_risk = min(max(task_risk + (hash(t) % 10 - 5), 0), 100)
             high_risk_phases.append({
                 "phase": phase,
                 "task": t,
                 "risk": round(task_risk, 1)
             })
 
-    # Generate hardcoded insights
+    # Generate insights
     insights = call_ai_model_for_insights(input_data, delay_risk)
 
     logger.info(f"Prediction completed: Delay risk = {delay_risk:.1f}%")
@@ -230,7 +274,7 @@ def predict_delay(input_data: Dict) -> Dict:
         "project": input_data.get("project_name", "Unnamed Project"),
         "phase": phase,
         "task": task,
-        "delay_probability": round(delay_risk, 1),
+        "delay_probability": delay_risk,
         "ai_insights": "; ".join(insights) if insights else "No significant delay factors detected.",
         "high_risk_phases": high_risk_phases,
         "weather_condition": weather_condition