Update app.py

app.py

@@ -2,7 +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
+from tensorflow.keras.layers 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
@@ -10,72 +10,36 @@ try:
     from tkat import TKAT
 except ImportError:
     print("TKAT library not found. If your model uses TKAT, make sure the library is installed.")
-    TKAT = None # Set to None if TKAT is not available
+    TKAT = None
 
 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.
+import pickle
+import os
+import requests
+import pandas as pd
+from datetime import datetime, timedelta, timezone
+import pytz # For timezone handling
 
 # --- Your MinMaxScaler Class (Copied from Notebook) ---
+# (Keep the MinMaxScaler class definition here as before)
 class MinMaxScaler:
+    # ... (MinMaxScaler class definition) ...
     def __init__(self, feature_axis=None, minmax_range=(0, 1)):
-        """
-        Initialize the MinMaxScaler.
-        Args:
-        feature_axis (int, optional): The axis that represents the feature dimension if applicable.
-                                      Use only for 3D data to specify which axis is the feature axis.
-                                      Default is None, automatically managed based on data dimensions.
-        """
         self.feature_axis = feature_axis
         self.min_ = None
         self.max_ = None
         self.scale_ = None
-        self.minmax_range = minmax_range # Default range for scaling (min, max)
+        self.minmax_range = minmax_range
 
     def fit(self, X):
-        """
-        Fit the scaler to the data based on its dimensionality.
-        Args:
-        X (np.array): The data to fit the scaler on.
-        """
-        if X.ndim == 3 and self.feature_axis is not None:  # 3D data
+        if X.ndim == 3 and self.feature_axis is not None:
             axis = tuple(i for i in range(X.ndim) if i != self.feature_axis)
             self.min_ = np.min(X, axis=axis)
             self.max_ = np.max(X, axis=axis)
-        elif X.ndim == 2:  # 2D data
+        elif X.ndim == 2:
             self.min_ = np.min(X, axis=0)
             self.max_ = np.max(X, axis=0)
-        elif X.ndim == 1:  # 1D data
+        elif X.ndim == 1:
             self.min_ = np.min(X)
             self.max_ = np.max(X)
         else:
@@ -85,173 +49,363 @@ class MinMaxScaler:
         return self
 
     def transform(self, X):
-        """
-        Transform the data using the fitted scaler.
-        Args:
-        X (np.array): The data to transform.
-        Returns:
-        np.array: The scaled data.
-        """
         X_scaled = (X - self.min_) / self.scale_
         X_scaled = X_scaled * (self.minmax_range[1] - self.minmax_range[0]) + self.minmax_range[0]
         return X_scaled
 
     def fit_transform(self, X):
-        """
-        Fit to data, then transform it.
-        Args:
-        X (np.array): The data to fit and transform.
-        Returns:
-        np.array: The scaled data.
-        """
         return self.fit(X).transform(X)
 
     def inverse_transform(self, X_scaled):
-        """
-        Inverse transform the scaled data to original data.
-        Args:
-        X_scaled (np.array): The scaled data to inverse transform.
-        Returns:
-        np.array: The original data scale.
-        """
         X = (X_scaled - self.minmax_range[0]) / (self.minmax_range[1] - self.minmax_range[0])
         X = X * self.scale_ + self.min_
         return X
-# --- End of MinMaxScaler Class ---
 
-# Add your custom MinMaxScaler to custom_objects
-custom_objects["MinMaxScaler"] = MinMaxScaler
 
+# --- AQI Breakpoints and Calculation Logic (Copied from Notebook) ---
+# (Keep the aqi_breakpoints and calculate_overall_aqi functions here as before)
+aqi_breakpoints = {
+    'pm25': [(0, 50, 0, 50), (51, 100, 51, 100), (101, 200, 101, 200), (201, 300, 201, 300)],
+    'pm10': [(0, 50, 0, 50), (51, 100, 51, 100), (101, 250, 101, 200), (251, 350, 201, 300)],
+    'co': [(0, 1.0, 0, 50), (1.1, 2.0, 51, 100), (2.1, 10.0, 101, 200), (10.1, 17.0, 201, 300)]
+}
+
+def calculate_sub_aqi(concentration, breakpoints):
+    for i_low, i_high, c_low, c_high in breakpoints:
+        if c_low <= concentration <= c_high:
+            if c_high == c_low:
+                 return i_low
+            return ((i_high - i_low) / (c_high - c_low)) * (concentration - c_low) + i_low
+    if concentration < breakpoints[0][2]:
+        return breakpoints[0][0]
+    elif concentration > breakpoints[-1][3]:
+        return breakpoints[-1][1]
+    else:
+        return np.nan
+
+def calculate_overall_aqi(row, aqi_breakpoints):
+    sub_aqis = []
+    pollutant_mapping = {
+        'pm2_5': 'pm25',
+        'pm10': 'pm10',
+        'carbon_monoxide': 'co',
+    }
+    for api_pollutant, internal_pollutant in pollutant_mapping.items():
+        concentration = row.get(api_pollutant, np.nan)
+        if not np.isnan(concentration):
+            sub_aqi = calculate_sub_aqi(concentration, aqi_breakpoints.get(internal_pollutant, []))
+            sub_aqis.append(sub_aqi)
+        else:
+            sub_aqis.append(np.nan)
+    return np.nanmax(sub_aqis) if sub_aqis and not all(np.isnan(sub_aqis)) else np.nan
+
+
+# --- Configuration ---
+MODEL_PATH = "best_model_TKAN_nahead_1 (2).keras"
+INPUT_SCALER_PATH = "input_scaler.pkl"
+TARGET_SCALER_PATH = "target_scaler.pkl"
+SEQUENCE_LENGTH = 24 # Matches the notebook
+NUM_INPUT_FEATURES = 5 # ['calculated_aqi', 'temp', 'pm25', 'pm10', 'co']
+N_AHEAD = 1 # Matches the notebook
+
+# --- Open-Meteo API Configuration ---
+OPENMETEO_AIR_QUALITY_API_URL = "https://air-quality-api.open-meteo.com/v1/air-quality"
+# You will also need the standard weather API for temperature
+OPENMETEO_WEATHER_API_URL = "https://api.open-meteo.com/v1/forecast" # Using forecast for recent hourly data
+# Replace with the actual latitude and longitude for your location
+LATITUDE = 17.33
+LONGITUDE = 78.27
+AIR_QUALITY_PARAMETERS = ["pm10", "pm2_5", "carbon_monoxide"]
+WEATHER_PARAMETERS_FOR_TEMP = ["temperature_2m"] # Parameter name for temperature
+TIMEZONE = "auto"
+
+# --- Ensure Required Files Exist ---
+# (Keep the file existence checks here as before)
+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.")
+
+if not os.path.exists(TARGET_SCALER_PATH):
+    print(f"Error: Target scaler file not found at {TARGET_SCALER_PATH}")
+    import sys
+    sys.exit("Target scaler file missing. Exiting.")
+
+
+# --- Load Model and Scalers ---
+# (Keep the loading logic here as before)
+custom_objects = {"TKAN": TKAN, "MinMaxScaler": MinMaxScaler}
+if TKAT is not None:
+    custom_objects["TKAT"] = TKAT
 
 model = None
 input_scaler = None
-# target_scaler = None # Load if needed
+target_scaler = None
 
 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() # Verify the model structure after loading
+        model.summary()
 
         with open(INPUT_SCALER_PATH, 'rb') as f:
             input_scaler = pickle.load(f)
         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): # 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}")
+        with open(TARGET_SCALER_PATH, 'rb') as f:
+            target_scaler = pickle.load(f)
+        print(f"Target scaler loaded successfully from {TARGET_SCALER_PATH}")
 
 except Exception as e:
     print(f"Error during loading: {e}")
     import traceback
     traceback.print_exc()
     import sys
-    sys.exit("Failed to load model or scaler. Exiting.")
+    sys.exit("Failed to load model or scaler(s). Exiting.")
 
 
-# --- Data Preparation (get_latest_data_sequence needs implementation) ---
+# --- Data Retrieval from Open-Meteo API ---
 
-def get_latest_data_sequence(sequence_length, num_features):
+def get_latest_data_sequence(sequence_length):
     """
-    Retrieves the latest sequence of data for the required features.
-
-    This function needs to be implemented based on your data source in the
-    deployment environment. It should return a numpy array with shape
-    (sequence_length, num_features).
+    Retrieves the latest sequence of air quality and temperature data from Open-Meteo
+    for the previous `sequence_length` hours based on the current hour,
+    calculates historical AQI, and formats it for model input.
 
     Args:
-        sequence_length (int): The length of the historical sequence required.
-        num_features (int): The number of features in each time step.
+        sequence_length (int): The length of the historical sequence required (e.g., 24).
 
     Returns:
         np.ndarray: A numpy array containing the historical data sequence.
-                    Shape: (sequence_length, num_features)
+                    Shape: (sequence_length, NUM_INPUT_FEATURES)
+                    Returns None or raises an error on failure.
     """
-    print("WARNING: Using dummy data sequence. Implement get_latest_data_sequence.")
-    # --- REPLACE THIS WITH YOUR ACTUAL DATA RETRIEVAL LOGIC ---
-    # 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
-    # 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 ---
-
+    print(f"Attempting to retrieve data for the last {sequence_length} hours from Open-Meteo...")
+
+    # Determine the exact start and end time for the last `sequence_length` hours
+    # The API uses YYYY-MM-DD format for dates.
+    # We need data from the hour `sequence_length` hours ago up to the current completed hour.
+    now_utc = datetime.now(timezone.utc)
+    # Round down to the nearest hour
+    current_hour_utc = now_utc.replace(minute=0, second=0, microsecond=0)
+    # The end date for the API request is the current date
+    end_date_api = current_hour_utc.strftime('%Y-%m-%d')
+    # The start date is `sequence_length` hours before the *start* of the current hour.
+    # So, `sequence_length` hours before `current_hour_utc`.
+    start_time_utc = current_hour_utc - timedelta(hours=sequence_length)
+    start_date_api = start_time_utc.strftime('%Y-%m-%d')
+
+    # --- Fetch Air Quality Data ---
+    aq_params = {
+        "latitude": LATITUDE,
+        "longitude": LONGITUDE,
+        "hourly": ",".join(AIR_QUALITY_PARAMETERS),
+        "timezone": TIMEZONE,
+        "start_date": start_date_api,
+        "end_date": end_date_api,
+         "domains": "auto"
+    }
+
+    try:
+        aq_response = requests.get(OPENMETEO_AIR_QUALITY_API_URL, params=aq_params)
+        aq_response.raise_for_status()
+        aq_data = aq_response.json()
+        print("Air quality data retrieved.")
+
+        if 'hourly' not in aq_data or 'time' not in aq_data['hourly']:
+            print("Error: 'hourly' or 'time' not found in AQ response.")
+            return None
+
+        aq_hourly_data = aq_data['hourly']
+        aq_timestamps = aq_hourly_data['time']
+        aq_extracted_data = {param: aq_hourly_data.get(param, []) for param in AIR_QUALITY_PARAMETERS}
+
+        df_aq = pd.DataFrame(aq_extracted_data, index=pd.to_datetime(aq_timestamps))
+
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching air quality data: {e}")
+        return None
+    except Exception as e:
+        print(f"Error processing air quality data: {e}")
+        import traceback
+        traceback.print_exc()
+        return None
+
+    # --- Fetch Temperature Data ---
+    temp_params = {
+        "latitude": LATITUDE,
+        "longitude": LONGITUDE,
+        "hourly": ",".join(WEATHER_PARAMETERS_FOR_TEMP),
+        "timezone": TIMEZONE,
+        "start_date": start_date_api,
+        "end_date": end_date_api,
+         "models": "best_match"
+    }
+
+    try:
+        temp_response = requests.get(OPENMETEO_WEATHER_API_URL, params=temp_params)
+        temp_response.raise_for_status()
+        temp_data = temp_response.json()
+        print("Temperature data retrieved.")
+
+        if 'hourly' not in temp_data or 'time' not in temp_data['hourly']:
+            print("Error: 'hourly' or 'time' not found in temperature response.")
+            # Decide how to handle missing temperature data - return None, fill with NaNs, etc.
+            print("Skipping temperature data due to missing fields.")
+            df_temp = pd.DataFrame(index=df_aq.index) # Create empty DataFrame with AQ index
+            for param in WEATHER_PARAMETERS_FOR_TEMP:
+                 df_temp[param] = np.nan # Add NaN columns for expected temperature parameters
+        else:
+            temp_hourly_data = temp_data['hourly']
+            temp_timestamps = temp_hourly_data['time']
+            temp_extracted_data = {param: temp_hourly_data.get(param, []) for param in WEATHER_PARAMETERS_FOR_TEMP}
+
+            df_temp = pd.DataFrame(temp_extracted_data, index=pd.to_datetime(temp_timestamps))
+
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching temperature data: {e}")
+        print("Skipping temperature data due to API error.")
+        df_temp = pd.DataFrame(index=df_aq.index) # Create empty DataFrame with AQ index
+        for param in WEATHER_PARAMETERS_FOR_TEMP:
+             df_temp[param] = np.nan # Add NaN columns for expected temperature parameters
+    except Exception as e:
+        print(f"Error processing temperature data: {e}")
+        import traceback
+        traceback.print_exc()
+        print("Skipping temperature data due to processing error.")
+        df_temp = pd.DataFrame(index=df_aq.index) # Create empty DataFrame with AQ index
+        for param in WEATHER_PARAMETERS_FOR_TEMP:
+             df_temp[param] = np.nan # Add NaN columns for expected temperature parameters
+
+
+    # --- Merge DataFrames ---
+    # Merge air quality and temperature data based on timestamp
+    df_merged = pd.merge(df_aq, df_temp, left_index=True, right_index=True, how='outer')
+
+    # --- Calculate Historical AQI ---
+    # Calculate the 'calculated_aqi' for each row using your function
+    df_merged['calculated_aqi'] = df_merged.apply(
+        lambda row: calculate_overall_aqi(
+            {'pm2_5': row.get('pm2_5'), 'pm10': row.get('pm10'), 'carbon_monoxide': row.get('carbon_monoxide')},
+            aqi_breakpoints
+        ),
+        axis=1
+    )
+
+    # --- Process and Filter Merged Data ---
+    # Ensure the index is a proper datetime index and sort
+    df_merged.index = pd.to_datetime(df_merged.index)
+    df_merged.sort_index(inplace=True)
+
+    # Resample to ensure hourly frequency and fill missing gaps
+    # Use forward fill then backward fill for robustness
+    df_processed = df_merged.resample('H').ffill().bfill()
+
+    # Filter to the exact time range for the sequence (last SEQUENCE_LENGTH hours)
+    # Find the timestamp corresponding to the start of the desired sequence
+    # We want the `sequence_length` hours ending at `current_hour_utc`
+    sequence_start_time_utc = current_hour_utc - timedelta(hours=sequence_length -1)
+
+    # Filter the DataFrame to include only the timestamps within the sequence
+    # Use loc with inclusive endpoints
+    df_sequence = df_processed.loc[sequence_start_time_utc:current_hour_utc]
+
+    # Ensure you have exactly SEQUENCE_LENGTH data points
+    if len(df_sequence) != sequence_length:
+         print(f"Error: Retrieved and processed data length ({len(df_sequence)}) does not match sequence length ({sequence_length}).")
+         print(f"Expected timestamps from {sequence_start_time_utc} to {current_hour_utc}. Got {df_sequence.index.min()} to {df_sequence.index.max()}.")
+         print("Check API request time range and data availability.")
+         return None
+
+    # Reorder columns to match your model's expected input feature order:
+    # ['calculated_aqi', 'temp', 'pm25', 'pm10', 'co']
+    # Ensure 'temp' is the column from temperature_2m, and pollutant names are mapped.
+
+    # Rename Open-Meteo columns to match your model's expected feature names
+    # (This mapping was partly in calculate_overall_aqi, but needed for the DataFrame columns)
+    column_rename_map = {
+        'temperature_2m': 'temp',
+        'pm2_5': 'pm25',
+        'pm10': 'pm10',
+        'carbon_monoxide': 'co',
+        # 'calculated_aqi' is already correct after calculation
+    }
+    df_sequence.rename(columns=column_rename_map, inplace=True)
+
+    # Ensure all expected features are present and in the correct order
+    model_features_order = ['calculated_aqi', 'temp', 'pm25', 'pm10', 'co']
+    missing_columns = [col for col in model_features_order if col not in df_sequence.columns]
+    if missing_columns:
+        print(f"Error: Missing required columns in final sequence data: {missing_columns}")
+        print("Ensure all expected features are fetched and named correctly.")
+        return None
+
+    # Select and reorder columns to match the model's expected input
+    df_final_sequence = df_sequence[model_features_order]
+
+    # Convert to numpy array
+    data_sequence = df_final_sequence.values
+
+    # Ensure the final numpy array has the correct shape (redundant but safe)
+    if data_sequence.shape != (sequence_length, NUM_INPUT_FEATURES):
+         print(f"Error: Final data sequence shape {data_sequence.shape} does not match expected shape ({sequence_length}, {NUM_INPUT_FEATURES}).")
+         return None
+
+    print(f"Successfully prepared data sequence with shape {data_sequence.shape}")
+    return data_sequence
 
 # --- Define Predict Function ---
-
-def predict(): # Modify inputs as needed based on how you get data
+# (Keep the predict function as before, it calls get_latest_data_sequence)
+def predict():
     """
-    Retrieves the latest data sequence, preprocesses it, and makes a prediction.
-
-    The Gradio interface will need to trigger this function.
+    Retrieves the latest data sequence from Open-Meteo, preprocesses it,
+    and makes a prediction.
     """
-    if model is None or input_scaler is None:
-         return "Model or scaler not loaded. Check logs."
+    if model is None or input_scaler is None or target_scaler is None:
+         return "Model or scaler(s) not loaded. Check logs."
+
+    # 1. Get the latest historical data sequence from Open-Meteo
+    latest_data_sequence = get_latest_data_sequence(SEQUENCE_LENGTH)
 
-    # 1. Get the latest historical data sequence
-    latest_data_sequence = get_latest_data_sequence(SEQUENCE_LENGTH, NUM_INPUT_FEATURES)
+    if latest_data_sequence is None:
+        return "Failed to retrieve or process latest data sequence."
 
-    # Ensure the retrieved data has the correct shape
+    # Ensure the retrieved data has the correct shape (redundant check, but safe)
     if latest_data_sequence.shape != (SEQUENCE_LENGTH, NUM_INPUT_FEATURES):
         return f"Error: Retrieved data has incorrect shape {latest_data_sequence.shape}. Expected ({SEQUENCE_LENGTH}, {NUM_INPUT_FEATURES})."
 
+
     # 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 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)
 
-    # 3. Perform prediction
-    # The model expects input shape (batch_size, sequence_length, num_features)
+    # 3. Perform prediction (outputs scaled target)
     output = model.predict(scaled_input_data)
 
-    # 4. Process the output
-    # The output shape is (batch_size, n_ahead). Since n_ahead=1, shape is (batch_size, 1).
-    predicted_scaled_value = output[0][0] # Get the first prediction for the first sample
-
-    # 5. Inverse transform the prediction if the target was scaled
-    # If you scaled the target variable (calculated_aqi) before training,
-    # you need to inverse transform the prediction back to the original scale.
-    # 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:
-    #     # 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
+    # 4. Process the output (get the scaled predicted value)
+    predicted_scaled_value = output[0][0]
 
-    # 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
+    # 5. Inverse transform the prediction using the target scaler
+    predicted_original_scale = target_scaler.inverse_transform(np.array([[predicted_scaled_value]]))[0][0]
 
-    return float(predicted_value)
+    predicted_value = predicted_original_scale
 
+    return float(predicted_value)
 
 # --- Gradio Interface ---
-# Keep inputs=None as the predict function gets data internally.
+# (Keep the Gradio interface as before, inputs=None)
 interface = gr.Interface(
     fn=predict,
-    inputs=None, # `predict` function doesn't take direct inputs from Gradio
+    inputs=None,
     outputs=gr.Number(label=f"Predicted AQI (Next {N_AHEAD} Hour(s))")
 )
 
+
 # --- Launch Gradio Interface ---
 if __name__ == "__main__":
     interface.launch()