Update inference.py

inference.py

@@ -1,9 +1,110 @@
+# import torch
+# import torch.nn as nn
+# import numpy as np
+# import pickle
+# import json
+# import os
+
+# class ImprovedCashFlowLSTM(nn.Module):
+#     def __init__(self, input_size, hidden_size=128, num_layers=2, forecast_horizon=13, dropout=0.2):
+#         super(ImprovedCashFlowLSTM, self).__init__()
+#         self.hidden_size = hidden_size
+#         self.num_layers = num_layers
+#         self.forecast_horizon = forecast_horizon
+#         self.lstm = nn.LSTM(
+#             input_size, 
+#             hidden_size, 
+#             num_layers, 
+#             dropout=dropout if num_layers > 1 else 0,
+#             batch_first=True
+#         )
+#         self.output_layers = nn.Sequential(
+#             nn.Linear(hidden_size, hidden_size),
+#             nn.ReLU(),
+#             nn.Dropout(dropout),
+#             nn.Linear(hidden_size, forecast_horizon)
+#         )
+    
+#     def forward(self, x):
+#         lstm_out, (hidden, cell) = self.lstm(x)
+#         last_hidden = lstm_out[:, -1, :]
+#         forecast = self.output_layers(last_hidden)
+#         return forecast
+
+# def load_model_and_artifacts(
+#     model_path="new_best_improved_model.pth",
+#     scaler_path="scaler.pkl",
+#     feature_names_path="feature_names.json",
+#     config_path="model_config.json"
+# ):
+#     """Load model, scaler, feature names, and configuration."""
+#     if not all(os.path.exists(path) for path in [model_path, scaler_path, feature_names_path, config_path]):
+#         missing = [path for path in [model_path, scaler_path, feature_names_path, config_path] if not os.path.exists(path)]
+#         raise FileNotFoundError(f"Missing files: {missing}")
+    
+#     with open(config_path, "r") as f:
+#         config = json.load(f)
+    
+#     with open(scaler_path, "rb") as f:
+#         scaler = pickle.load(f)
+    
+#     with open(feature_names_path, "r") as f:
+#         feature_names = json.load(f)
+    
+#     input_size = config["input_size"]
+#     model = ImprovedCashFlowLSTM(
+#         input_size=input_size,
+#         hidden_size=config["hidden_size"],
+#         num_layers=config["num_layers"],
+#         forecast_horizon=config["forecast_horizon"],
+#         dropout=config["dropout"]
+#     )
+#     model.load_state_dict(torch.load(model_path, map_location=torch.device("cpu")))
+#     model.eval()
+#     return model, scaler, feature_names, config
+
+# def predict(model, scaler, sequences):
+#     """Generate 13-week sales forecasts from input sequences."""
+#     device = torch.device("cpu")
+#     model.to(device)
+    
+#     # Validate input shape: (batch_size, sequence_length=21, n_features=20)
+#     if len(sequences.shape) != 3 or sequences.shape[1] != 21 or sequences.shape[2] != model.lstm.input_size:
+#         raise ValueError(f"Expected input shape (batch_size, 21, {model.lstm.input_size}), got {sequences.shape}")
+    
+#     # Convert to tensor
+#     sequences = torch.tensor(sequences, dtype=torch.float32).to(device)
+    
+#     # Generate predictions
+#     with torch.no_grad():
+#         predictions = model(sequences).cpu().numpy()  # Shape: (batch_size, 13)
+    
+#     # Inverse transform predictions (sales is first feature)
+#     dummy = np.zeros((predictions.shape[0] * predictions.shape[1], scaler.n_features_in_))
+#     dummy[:, 0] = predictions.flatten()
+#     rescaled = scaler.inverse_transform(dummy)[:, 0].reshape(predictions.shape)
+    
+#     # Ensure non-negative predictions and clip to training range
+#     rescaled = np.maximum(rescaled, 0)
+#     rescaled = np.clip(rescaled, 3000, 19372)  # Training sales range: $3069–19372
+    
+#     # Estimate uncertainty: scaled std of predictions per sequence, repeated for each timestep
+#     uncertainties = 0.2 * np.std(rescaled, axis=1, keepdims=True) + 100  # Shape: (batch_size, 1)
+#     uncertainties = np.repeat(uncertainties, rescaled.shape[1], axis=1)  # Shape: (batch_size, 13)
+#     uncertainties = np.clip(uncertainties, 100, 1000)  # Wider bounds to avoid constant clipping
+    
+#     return rescaled, uncertainties
+
+
+
 import torch
 import torch.nn as nn
 import numpy as np
+import pandas as pd
 import pickle
 import json
 import os
+from datetime import datetime
 
 class ImprovedCashFlowLSTM(nn.Module):
     def __init__(self, input_size, hidden_size=128, num_layers=2, forecast_horizon=13, dropout=0.2):
@@ -63,6 +164,48 @@ def load_model_and_artifacts(
     model.eval()
     return model, scaler, feature_names, config
 
+def derive_features(df, feature_names, sequence_length=21):
+    """Derive 20 features from minimal input columns: date, sales, onpromotion, dcoilwtico, is_holiday."""
+    required_columns = ["date", "sales", "onpromotion", "dcoilwtico", "is_holiday"]
+    if not all(col in df.columns for col in required_columns):
+        raise ValueError(f"CSV must contain columns: {', '.join(required_columns)}")
+    if len(df) != sequence_length:
+        raise ValueError(f"CSV must have exactly {sequence_length} rows, got {len(df)}")
+    
+    # Convert date to datetime
+    df["date"] = pd.to_datetime(df["date"])
+    
+    # Initialize output DataFrame with all required features
+    feature_df = pd.DataFrame(0.0, index=df.index, columns=feature_names)
+    
+    # Copy direct input features
+    for col in ["sales", "onpromotion", "dcoilwtico", "is_holiday"]:
+        feature_df[col] = df[col]
+    
+    # Derive temporal features
+    feature_df["trend"] = np.linspace(0, sequence_length - 1, sequence_length)
+    feature_df["dayofweek_sin"] = np.sin(2 * np.pi * df["date"].dt.dayofweek / 7)
+    feature_df["dayofweek_cos"] = np.cos(2 * np.pi * df["date"].dt.dayofweek / 7)
+    feature_df["month_sin"] = np.sin(2 * np.pi * df["date"].dt.month / 12)
+    feature_df["month_cos"] = np.cos(2 * np.pi * df["date"].dt.month / 12)
+    feature_df["quarter"] = df["date"].dt.quarter
+    feature_df["is_weekend"] = (df["date"].dt.dayofweek >= 5).astype(float)
+    
+    # Derive lag features
+    for lag in [1, 2, 3]:
+        feature_df[f"lag_{lag}"] = df["sales"].shift(lag).fillna(df["sales"].iloc[0])
+    
+    # Derive moving average and ratio features
+    for window in [7, 14]:
+        feature_df[f"ma_{window}"] = df["sales"].rolling(window=window, min_periods=1).mean()
+        feature_df[f"ratio_{window}"] = df["sales"] / (feature_df[f"ma_{window}"] + 1e-8)
+    
+    # Derive promotion lag features
+    for lag in [1, 2]:
+        feature_df[f"promo_lag_{lag}"] = df["onpromotion"].shift(lag).fillna(df["onpromotion"].iloc[0])
+    
+    return feature_df[feature_names].values
+
 def predict(model, scaler, sequences):
     """Generate 13-week sales forecasts from input sequences."""
     device = torch.device("cpu")
@@ -93,4 +236,4 @@ def predict(model, scaler, sequences):
     uncertainties = np.repeat(uncertainties, rescaled.shape[1], axis=1)  # Shape: (batch_size, 13)
     uncertainties = np.clip(uncertainties, 100, 1000)  # Wider bounds to avoid constant clipping
     
-    return rescaled, uncertainties
+    return rescaled, uncertainties