deployment issues

app.py

@@ -28,11 +28,11 @@ lstm_model = tf.keras.models.load_model("lstm_model.keras")  # LSTM model
 scaler_X = MinMaxScaler(feature_range=(0, 1))
 scaler_y = MinMaxScaler(feature_range=(0, 1))
 
-# Fit scalers on the training data
+# Scale training data
 X_train_scaled = scaler_X.fit_transform(train_data['Sessions'].values.reshape(-1, 1))
 y_train_scaled = scaler_y.fit_transform(train_data['Sessions'].values.reshape(-1, 1))
 
-# Scale the test data
+# Scale test data
 X_test_scaled = scaler_X.transform(test_data['Sessions'].values.reshape(-1, 1))
 y_test_scaled = scaler_y.transform(test_data['Sessions'].values.reshape(-1, 1))
 
@@ -40,83 +40,85 @@ y_test_scaled = scaler_y.transform(test_data['Sessions'].values.reshape(-1, 1))
 X_test_lstm = X_test_scaled.reshape((X_test_scaled.shape[0], 1, 1))
 
 # Generate predictions for SARIMA
-sarima_predictions = sarima_model.predict(start=len(train_data), end=len(webtraffic_data) - 1)
+future_periods = len(test_data)
+sarima_predictions = sarima_model.predict(n_periods=future_periods)
 
 # Generate predictions for LSTM
-lstm_predictions_scaled = lstm_model.predict(X_test_lstm)
-lstm_predictions = scaler_y.inverse_transform(lstm_predictions_scaled).flatten()
+lstm_predictions_scaled = lstm_model.predict(X_test_lstm[:future_periods])
+lstm_predictions = scaler_y.inverse_transform(lstm_predictions_scaled)
 
 # Combine predictions into a DataFrame for visualization
 future_predictions = pd.DataFrame({
     "Datetime": test_data['Datetime'],
     "SARIMA_Predicted": sarima_predictions,
-    "LSTM_Predicted": lstm_predictions
+    "LSTM_Predicted": lstm_predictions.flatten()
 })
 
 # Calculate metrics
-mae_sarima = mean_absolute_error(test_data['Sessions'], sarima_predictions)
-rmse_sarima = mean_squared_error(test_data['Sessions'], sarima_predictions, squared=False)
+mae_sarima_future = mean_absolute_error(test_data['Sessions'], sarima_predictions)
+rmse_sarima_future = mean_squared_error(test_data['Sessions'], sarima_predictions, squared=False)
 
-mae_lstm = mean_absolute_error(test_data['Sessions'], lstm_predictions)
-rmse_lstm = mean_squared_error(test_data['Sessions'], lstm_predictions, squared=False)
+mae_lstm_future = mean_absolute_error(test_data['Sessions'], lstm_predictions)
+rmse_lstm_future = mean_squared_error(test_data['Sessions'], lstm_predictions, squared=False)
 
-# Function to generate plots
-def generate_plot(model):
-    """Generate plot based on the selected model."""
+# Function to plot actual vs. predicted traffic
+def plot_predictions():
     plt.figure(figsize=(15, 6))
-    plt.plot(test_data['Datetime'], test_data['Sessions'], label='Actual Traffic', color='black', linestyle='dotted', linewidth=2)
 
-    if model == "SARIMA":
-        plt.plot(future_predictions['Datetime'], future_predictions['SARIMA_Predicted'], label='SARIMA Predicted', color='blue', linewidth=2)
-    elif model == "LSTM":
-        plt.plot(future_predictions['Datetime'], future_predictions['LSTM_Predicted'], label='LSTM Predicted', color='green', linewidth=2)
+    # Plot actual traffic
+    plt.plot(webtraffic_data['Datetime'].iloc[-future_periods:],
+             test_data['Sessions'].values[-future_periods:],
+             label='Actual Traffic', color='black', linestyle='dotted', linewidth=2)
 
-    plt.title(f"{model} Predictions vs Actual Traffic", fontsize=16)
+    # Plot SARIMA predictions
+    plt.plot(future_predictions['Datetime'],
+             future_predictions['SARIMA_Predicted'],
+             label='SARIMA Predicted', color='blue', linewidth=2)
+
+    # Plot LSTM predictions
+    plt.plot(future_predictions['Datetime'],
+             future_predictions['LSTM_Predicted'],
+             label='LSTM Predicted', color='green', linewidth=2)
+
+    plt.title("Future Traffic Predictions: SARIMA vs LSTM", fontsize=16)
     plt.xlabel("Datetime", fontsize=12)
     plt.ylabel("Sessions", fontsize=12)
     plt.legend(loc="upper left")
     plt.grid(True)
     plt.tight_layout()
-    plot_path = f"{model.lower()}_plot.png"
+
+    # Save the plot to a file
+    plot_path = "/content/predictions_plot.png"
     plt.savefig(plot_path)
     plt.close()
     return plot_path
 
-# Function to display metrics
+# Function to display prediction metrics
 def display_metrics():
-    """Generate metrics for both models."""
     metrics = {
         "Model": ["SARIMA", "LSTM"],
-        "Mean Absolute Error (MAE)": [mae_sarima, mae_lstm],
-        "Root Mean Squared Error (RMSE)": [rmse_sarima, rmse_lstm]
+        "Mean Absolute Error (MAE)": [mae_sarima_future, mae_lstm_future],
+        "Root Mean Squared Error (RMSE)": [rmse_sarima_future, rmse_lstm_future]
     }
     return pd.DataFrame(metrics)
 
-# Gradio interface function
-def dashboard_interface(model="SARIMA"):
-    """Generate plot and metrics for the selected model."""
-    plot_path = generate_plot(model)
+# Gradio function to display the dashboard
+def gradio_dashboard():
+    plot_path = plot_predictions()
     metrics_df = display_metrics()
     return plot_path, metrics_df.to_string()
 
-# Build the Gradio dashboard
+# Gradio interface
 with gr.Blocks() as dashboard:
     gr.Markdown("## Web Traffic Prediction Dashboard")
-    gr.Markdown("Select a model to view its predictions and performance metrics.")
+    gr.Markdown("This dashboard compares predictions from SARIMA and LSTM models.")
 
-    # Dropdown for model selection
-    model_selection = gr.Dropdown(["SARIMA", "LSTM"], label="Select Model", value="SARIMA")
-
-    # Outputs: Plot and Metrics
+    # Show the plot
     plot_output = gr.Image(label="Prediction Plot")
-    metrics_output = gr.Textbox(label="Metrics", lines=10)
-
-    # Button to update dashboard
-    gr.Button("Update Dashboard").click(
-        fn=dashboard_interface,
-        inputs=[model_selection],
-        outputs=[plot_output, metrics_output]
-    )
+    metrics_output = gr.Textbox(label="Prediction Metrics", lines=15)
+
+    # Define the Gradio button and actions
+    gr.Button("Update Dashboard").click(gradio_dashboard, outputs=[plot_output, metrics_output])
 
 # Launch the dashboard
 dashboard.launch()