Add dashboard app

app.py

@@ -1,134 +1,109 @@
 import gradio as gr
-from transformers import pipeline
-import numpy as np
 import hopsworks
+import pandas as pd
+import matplotlib.pyplot as plt
+import os
 from xgboost import XGBRegressor
-import joblib
-from openai import OpenAI
-from functions.llm_chain import (
-    load_model,
-    get_llm_chain,
-    generate_response,
-    generate_response_openai,
-)
-# Initialize the ASR pipeline
-transcriber = pipeline("automatic-speech-recognition", model="openai/whisper-base.en")
-
-def connect_to_hopsworks():
-    # Initialize Hopsworks feature store connection
-    project = hopsworks.login()
-    fs = project.get_feature_store()
 
-    # Retrieve the model registry
+# IMPORTANT: HuggingFace builds need non-interactive backend
+import matplotlib
+matplotlib.use("Agg")
+
+FEATURE_COLUMNS = [
+    "temperature_2m_mean",
+    "precipitation_sum",
+    "wind_speed_10m_max",
+    "wind_direction_10m_dominant"
+]
+
+def load_resources():
+    """Connect to Hopsworks, load model + feature view."""
+    project = hopsworks.login(
+        api_key=os.environ["HOPSWORKS_API_KEY"],
+        host=os.environ["HOPSWORKS_HOST"],
+    )
+
+    fs = project.get_feature_store()
     mr = project.get_model_registry()
 
-    # Retrieve the 'air_quality_fv' feature view
-    feature_view = fs.get_feature_view(
-        name="air_quality_fv",
-        version=1,
-        )
+    # Load model
+    model_meta = mr.get_model("air_quality_xgboost_model", version=1)
+    model_dir = model_meta.download()
+    model = XGBRegressor()
+    model.load_model(model_dir + "/model.json")
+
+    # Load feature view
+    fv = fs.get_feature_view("air_quality_fv", version=1)
+
+    return model, fv
+
+# Load on startup
+model, feature_view = load_resources()
+
+def generate_forecast():
+    """Fetch latest feature data, generate PM25 forecast plot."""
+    df = feature_view.get_batch_data()
 
-    # Initialize batch scoring
-    feature_view.init_batch_scoring(1)
+    # Convert timestamp to datetime
+    df["date"] = pd.to_datetime(df["date"], unit="us")
 
-    # Retrieve the 'air_quality_xgboost_model' from the model registry
-    retrieved_model = mr.get_model(name="air_quality_xgboost_model", version=1)
+    # Predict PM2.5
+    df["predicted_pm25"] = model.predict(df[FEATURE_COLUMNS])
 
-    # Download the saved model artifacts to a local directory
-    saved_model_dir = retrieved_model.download()
+    # Plot forecast
+    plt.figure(figsize=(10, 4))
+    plt.plot(df["date"], df["predicted_pm25"], marker="o")
+    plt.title("PM2.5 Forecast (Next Days)")
+    plt.xlabel("Date")
+    plt.ylabel("Predicted PM2.5")
+    plt.grid(True)
+    plt.tight_layout()
+    plt.savefig("forecast.png")
+    plt.close()
 
-    # Load the XGBoost regressor model and label encoder from the saved model directory
-    # model_air_quality = joblib.load(saved_model_dir + "/xgboost_regressor.pkl")
-    # Loading the XGBoost regressor model and label encoder from the saved model directory
-    # retrieved_xgboost_model = joblib.load(saved_model_dir + "/xgboost_regressor.pkl")
-    model_air_quality = XGBRegressor()
+    return "forecast.png"
 
-    model_air_quality.load_model(saved_model_dir + "/model.json")
+def generate_hindcast():
+    """Generate hindcast accuracy plot (past days)."""
+    df = feature_view.get_batch_data()
+    df["date"] = pd.to_datetime(df["date"], unit="us")
+    df["predicted_pm25"] = model.predict(df[FEATURE_COLUMNS])
 
-    return feature_view, model_air_quality
+    # For hindcast: show difference between predicted & actual (most recent available data)
+    # NOTE: Your data may not include true pm25 for recent dates; 
+    # we'll plot model signal only.
 
+    plt.figure(figsize=(10, 4))
+    plt.plot(df["date"], df["predicted_pm25"], label="Predicted", marker="o")
+    plt.title("PM2.5 Hindcast (Recent Days)")
+    plt.xlabel("Date")
+    plt.ylabel("PM2.5")
+    plt.grid(True)
+    plt.legend()
+    plt.tight_layout()
+    plt.savefig("hindcast.png")
+    plt.close()
 
-def retrieve_llm_chain():
-    model_llm, tokenizer = load_model()
-    llm_chain = get_llm_chain(
-        model_llm,
-        tokenizer,
+    return "hindcast.png"
+
+
+def run_dashboard():
+    forecast_img = generate_forecast()
+    hindcast_img = generate_hindcast()
+    return forecast_img, hindcast_img
+
+
+with gr.Blocks() as demo:
+    gr.Markdown("# 🌤️ PM2.5 Air Quality Dashboard")
+    gr.Markdown("Powered by Hopsworks Feature Store + XGBoost Model")
+
+    btn = gr.Button("Generate Forecast")
+    output_forecast = gr.Image(label="Forecast (Next Days)")
+    output_hindcast = gr.Image(label="Hindcast (Past Days)")
+
+    btn.click(
+        run_dashboard,
+        outputs=[output_forecast, output_hindcast]
     )
-    return model_llm, tokenizer, llm_chain
-
-# Setup the models and feature view
-feature_view, model_air_quality = connect_to_hopsworks()
-
-def transcribe(audio):
-    sr, y = audio
-    y = y.astype(np.float32)
-    if y.ndim > 1 and y.shape[1] > 1:
-        y = np.mean(y, axis=1)
-    y /= np.max(np.abs(y))
-    return transcriber({"sampling_rate": sr, "raw": y})["text"]
-
-
-def generate_query_response(user_query, method, openai_api_key=None):
-    if method == 'Hermes LLM':
-        # Load the LLM and its corresponding tokenizer and configure a language model chain
-        model_llm, tokenizer, llm_chain = retrieve_llm_chain()
-
-        response = generate_response(
-            user_query,
-            feature_view,
-            model_air_quality,
-            model_llm,
-            tokenizer,
-            llm_chain,
-            verbose=False,
-        )
-        return response
-
-    elif method == 'OpenAI API' and openai_api_key:
-        client = OpenAI(
-            api_key=openai_api_key
-        )
-
-        response = generate_response_openai(
-            user_query,
-            feature_view,
-            model_air_quality,
-            client,
-            verbose=False,
-        )
-        return response
-
-    else:
-        return "Invalid method or missing API key."
-
-
-def handle_input(text_input=None, audio_input=None, method='Hermes LLM', openai_api_key=""):
-    if audio_input is not None:
-        user_query = transcribe(audio_input)
-    else:
-        user_query = text_input
-
-    # Check if OpenAI API key is required but not provided
-    if method == 'OpenAI API' and not openai_api_key.strip():
-        return "OpenAI API key is required for this method."
-
-    if user_query:
-        return generate_query_response(user_query, method, openai_api_key)
-    else:
-        return "Please provide input either via text or voice."
-
-# Setting up the Gradio Interface
-iface = gr.Interface(
-    fn=handle_input,
-    inputs=[
-        gr.Textbox(placeholder="Type here or use voice input..."),
-        gr.Audio(),
-        gr.Radio(["Hermes LLM", "OpenAI API"], label="Choose the response generation method"),
-        gr.Textbox(label="Enter your OpenAI API key (only if you selected OpenAI API):", type="password")  # Removed `optional=True`
-    ],
-    outputs="text",
-    title="🌤️ AirQuality AI Assistant 💬",
-    description="Ask your questions about air quality or use your voice to interact. Select the response generation method and provide an OpenAI API key if necessary."
-)
-
-iface.launch(share=True)
+
+demo.launch()

requirements.txt

@@ -0,0 +1,6 @@
+gradio
+hopsworks
+pandas
+xgboost
+matplotlib
+numpy

requirements.txt.txt

@@ -1,18 +0,0 @@
-hopsworks[python,great-expectations]
-streamlit==1.28.2
-email-validator==2.2.0
-pydantic-settings>=2.6.1
-geopy==2.4.1
-openmeteo-requests
-requests-cache==1.2.0
-retry-requests==2.0.0
-xgboost==2.0.3
-scikit-learn==1.2.2
-matplotlib==3.8.3
-plotly
-seaborn
-nbformat
-Faker
-invoke
-python-dotenv
-#feldera==0.41