Update app.py

app.py

@@ -2,6 +2,7 @@ import gradio as gr
 import numpy as np
 import tensorflow as tf
 from tensorflow.keras.models import load_model
+from tensorflow.keras.layers import Input # Explicitly import Input
 # Assuming TKAN and TKAT are available after installing the respective packages
 from tkan import TKAN
 # If TKAT is from a different library, import it similarly
@@ -13,6 +14,37 @@ except ImportError:
 
 from tensorflow.keras.utils import custom_object_scope
 import pickle # Used for saving/loading the scaler
+import os # For checking file existence
+
+# --- Configuration ---
+MODEL_PATH = "best_model_TKAN_nahead_1 (2).keras" # Your saved model file
+INPUT_SCALER_PATH = "input_scaler.pkl" # Your saved input scaler file
+SEQUENCE_LENGTH = 24 # Matches the notebook
+NUM_INPUT_FEATURES = 5 # ['calculated_aqi', 'temp', 'pm25', 'pm10', 'co']
+N_AHEAD = 1 # Matches the notebook
+
+# --- Ensure Required Files Exist ---
+if not os.path.exists(MODEL_PATH):
+    print(f"Error: Model file not found at {MODEL_PATH}")
+    import sys
+    sys.exit("Model file missing. Exiting.")
+
+if not os.path.exists(INPUT_SCALER_PATH):
+    print(f"Error: Input scaler file not found at {INPUT_SCALER_PATH}")
+    import sys
+    sys.exit("Input scaler file missing. Exiting.")
+
+
+# --- Load Model and Scalers ---
+# Define custom objects dictionary
+custom_objects = {"TKAN": TKAN}
+if TKAT is not None:
+    custom_objects["TKAT"] = TKAT
+# Add your custom MinMaxScaler to custom_objects if you are using one that you defined
+# in your own code (not from a library). If your scaler is from scikit-learn, you
+# generally don't need to include it in custom_objects for pickle loading, but if it's
+# a custom implementation, you do. Based on your notebook, you have a custom MinMaxScaler.
+# Include the custom MinMaxScaler class definition here as well.
 
 # --- Your MinMaxScaler Class (Copied from Notebook) ---
 class MinMaxScaler:
@@ -87,20 +119,7 @@ class MinMaxScaler:
         return X
 # --- End of MinMaxScaler Class ---
 
-
-# --- Configuration ---
-MODEL_PATH = "best_model_TKAN_nahead_1 (2).keras"
-INPUT_SCALER_PATH = "input_scaler.pkl" # You need to save your X_scaler to this file
-# TARGET_SCALER_PATH = "target_scaler.pkl" # You might also need this if you predict scaled target
-SEQUENCE_LENGTH = 24 # Matches the notebook
-NUM_INPUT_FEATURES = 5 # ['calculated_aqi', 'temp', 'pm25', 'pm10', 'co']
-N_AHEAD = 1 # Matches the notebook
-
-# --- Load Model and Scalers ---
-custom_objects = {"TKAN": TKAN}
-if TKAT is not None:
-    custom_objects["TKAT"] = TKAT
-# Also add your custom MinMaxScaler to custom_objects for loading the scaler object
+# Add your custom MinMaxScaler to custom_objects
 custom_objects["MinMaxScaler"] = MinMaxScaler
 
 
@@ -109,42 +128,29 @@ input_scaler = None
 # target_scaler = None # Load if needed
 
 try:
+    # Use custom_object_scope for both model and scaler loading
     with custom_object_scope(custom_objects):
         model = load_model(MODEL_PATH)
-    print("Model loaded successfully!")
-    model.summary()
-
-except Exception as e:
-    print(f"Error loading model from {MODEL_PATH}: {e}")
-    import traceback
-    traceback.print_exc()
-    import sys
-    sys.exit("Failed to load the model. Exiting.")
+        print("Model loaded successfully!")
+        model.summary() # Verify the model structure after loading
 
-try:
-    # When loading the scaler, you need custom_objects if it's your custom class
-    with custom_object_scope(custom_objects):
         with open(INPUT_SCALER_PATH, 'rb') as f:
             input_scaler = pickle.load(f)
-    print(f"Input scaler loaded successfully from {INPUT_SCALER_PATH}")
+        print(f"Input scaler loaded successfully from {INPUT_SCALER_PATH}")
 
     # If you also scaled your target variable and need to inverse transform the prediction,
     # load the target scaler here as well.
-    # with custom_object_scope(custom_objects):
+    # with custom_object_scope(custom_objects): # Need custom_object_scope if target scaler is custom
     #     with open(TARGET_SCALER_PATH, 'rb') as f:
     #         target_scaler = pickle.load(f)
     # print(f"Target scaler loaded successfully from {TARGET_SCALER_PATH}")
 
-except FileNotFoundError as e:
-    print(f"Error loading scaler: {e}. Make sure your scaler files are in the correct path.")
-    import sys
-    sys.exit("Failed to load scaler(s). Exiting.")
 except Exception as e:
-    print(f"Error loading scaler: {e}")
+    print(f"Error during loading: {e}")
     import traceback
     traceback.print_exc()
     import sys
-    sys.exit("Failed to load scaler(s). Exiting.")
+    sys.exit("Failed to load model or scaler. Exiting.")
 
 
 # --- Data Preparation (get_latest_data_sequence needs implementation) ---
@@ -167,15 +173,14 @@ def get_latest_data_sequence(sequence_length, num_features):
     """
     print("WARNING: Using dummy data sequence. Implement get_latest_data_sequence.")
     # --- REPLACE THIS WITH YOUR ACTUAL DATA RETRIEVAL LOGIC ---
-    # Example: Load from a database, fetch from an API, read from a file.
     # The data should be in the correct order (oldest to newest time step).
     # The columns should be in the order ['calculated_aqi', 'temp', 'pm25', 'pm10', 'co'].
 
     # For now, returning a placeholder with the correct shape.
     dummy_data = np.zeros((sequence_length, num_features))
     # Populate dummy_data with some values for testing if you can load historical data
-    # For example, load a small sample of your training data's X_test_unscaled
-    # and use it here temporarily to verify the scaling and prediction pipeline.
+    # Example: If you saved a sample of X_test_unscaled, load it here temporarily.
+    # You need to ensure this dummy data has the correct structure and feature order.
     return dummy_data
     # --- END OF PLACEHOLDER ---
 
@@ -187,8 +192,6 @@ def predict(): # Modify inputs as needed based on how you get data
     Retrieves the latest data sequence, preprocesses it, and makes a prediction.
 
     The Gradio interface will need to trigger this function.
-    The input parameters to this function might change depending on how you
-    provide the necessary historical data sequence via the Gradio interface.
     """
     if model is None or input_scaler is None:
          return "Model or scaler not loaded. Check logs."
@@ -202,7 +205,7 @@ def predict(): # Modify inputs as needed based on how you get data
 
     # 2. Scale the data sequence using the loaded input scaler
     # Your MinMaxScaler from the notebook had feature_axis=2 for 3D data (samples, sequence, features).
-    # So, for a single sequence (2D array), you'll likely need to add a batch dimension (1) before scaling.
+    # So, for a single sequence (2D array), you need to add a batch dimension (1) before scaling.
     latest_data_sequence_with_batch = latest_data_sequence[np.newaxis, :, :]
     scaled_input_data = input_scaler.transform(latest_data_sequence_with_batch)
 
@@ -220,43 +223,35 @@ def predict(): # Modify inputs as needed based on how you get data
     # This requires saving and loading the target_scaler as well and using it here.
 
     # Example if you need to inverse transform the target:
-    # if target_scaler is not None:
-    #     predicted_original_scale = target_scaler.inverse_transform(np.array([[predicted_scaled_value]]))[0][0]
-    # else:
-    #     predicted_original_scale = predicted_scaled_value
-    # predicted_value = predicted_original_scale
+    if target_scaler is not None:
+    #     # Need to put the single predicted value into an array with the shape
+    #     # that the target_scaler's inverse_transform expects.
+    #     # Assuming y_scaler was fitted on a shape like (samples, n_ahead, 1) or (samples, 1)
+    #     # and inverse_transform works on a similar shape.
+    #     # If y_train shape was (samples, n_ahead):
+        predicted_original_scale = target_scaler.inverse_transform(np.array([[predicted_scaled_value]]))[0][0]
+    #     # If y_train shape was (samples, n_ahead, 1):
+    #     # predicted_original_scale = target_scaler.inverse_transform(np.array([[[predicted_scaled_value]]]))[0][0][0]
+    #     pass # Implement the correct inverse transform based on how y_scaler was used
+    else:
+        predicted_original_scale = predicted_scaled_value
+    predicted_value = predicted_original_scale
 
     # For now, assuming the model outputs directly in the desired scale or
     # you handle inverse transformation elsewhere if needed.
-    predicted_value = predicted_scaled_value # Adjust this if inverse transformation is needed
+    # predicted_value = predicted_scaled_value # Adjust this if inverse transformation is needed
 
     return float(predicted_value)
 
 
 # --- Gradio Interface ---
-# The Gradio interface needs to allow the user to provide the necessary
-# historical data for the `predict` function. The current inputs (pm25, pm10, co, temp)
-# are NOT used by the predict function as written, since predict calls `get_latest_data_sequence`.
-# You need to decide how the user will provide the historical data.
-
-# Option 1: No direct inputs to `predict` function, it fetches data internally.
-# In this case, the Gradio interface might just have a button to trigger the prediction.
+# Keep inputs=None as the predict function gets data internally.
 interface = gr.Interface(
     fn=predict,
     inputs=None, # `predict` function doesn't take direct inputs from Gradio
     outputs=gr.Number(label=f"Predicted AQI (Next {N_AHEAD} Hour(s))")
 )
 
-# Option 2: Modify `predict` to accept some parameters that help retrieve the data.
-# For example, if you pass the current time, and `get_latest_data_sequence` uses that
-# to find the last 24 hours ending at that time.
-
-# Option 3: Design a more complex Gradio interface to input the full sequence.
-# This is more complex but directly aligns with the model input.
-
-# Choose the Gradio interface definition that matches how your `predict` function
-# will receive the data it needs. Option 1 is shown below.
-
 # --- Launch Gradio Interface ---
 if __name__ == "__main__":
     interface.launch()