new models

app.py

@@ -34,8 +34,7 @@ DISPLAY_TO_INTERNAL = {v: k for k, v in SENSOR_LABELS.items()}
 # HOPSWORKS + MODEL LOADING (LAZY)
 # -------------------------
 
-_resources_v1 = None
-_resources_v2 = None
+_resources = None
 
 
 def _login_hopsworks():
@@ -49,44 +48,22 @@ def _login_hopsworks():
     return project
 
 
-def load_resources_v1():
-    """Connect to Hopsworks and load model + feature view for v1."""
-    project = _login_hopsworks()
-    fs = project.get_feature_store()
-
-    fv = fs.get_feature_view("air_quality_fv", version=1)
-    fv.init_batch_scoring(1)
-
-    weather_fg = fs.get_feature_group("weather", version=1)
-
-    mr = project.get_model_registry()
-    model_obj = mr.get_model("air_quality_xgboost_model", version=1)
-    model_dir = model_obj.download()
-
-    model = XGBRegressor()
-    model.load_model(model_dir + "/model.json")
-
-    return {
-        "project": project,
-        "fs": fs,
-        "fv": fv,
-        "weather_fg": weather_fg,
-        "model": model,
-    }
-
+def load_resources():
+    """
+    Connect to Hopsworks and load model + feature view + weather FG.
 
-def load_resources_v2():
-    """Connect to Hopsworks and load model + feature view for v2."""
+    This is our SINGLE lag-aware model setup.
+    """
     project = _login_hopsworks()
     fs = project.get_feature_store()
 
-    fv = fs.get_feature_view("air_quality_fv", version=2)
+    fv = fs.get_feature_view("dundee_fv", version=3)  # lag-feature FeatureView
     fv.init_batch_scoring(1)
 
-    weather_fg = fs.get_feature_group("weather", version=1)
+    weather_fg = fs.get_feature_group("dundee_weather_fg", version=1)
 
     mr = project.get_model_registry()
-    model_obj = mr.get_model("air_quality_xgboost_model", version=2)
+    model_obj = mr.get_model("dundee_pm25_xgboostl", version=2)
     model_dir = model_obj.download()
 
     model = XGBRegressor()
@@ -101,25 +78,16 @@ def load_resources_v2():
     }
 
 
-def get_resources(model_version: str):
-    """Lazy loader for resources, cached per model version."""
-    global _resources_v1, _resources_v2
-
-    if model_version == "v1":
-        if _resources_v1 is None:
-            _resources_v1 = load_resources_v1()
-        return _resources_v1
-
-    if model_version == "v2":
-        if _resources_v2 is None:
-            _resources_v2 = load_resources_v2()
-        return _resources_v2
-
-    raise ValueError(f"Unknown model version: {model_version}")
+def get_resources():
+    """Lazy loader for the single model configuration."""
+    global _resources
+    if _resources is None:
+        _resources = load_resources()
+    return _resources
 
 
 # -------------------------
-# HELPER: AQI CATEGORY
+# HELPER: AQI CATEGORY (optional, not yet used in UI)
 # -------------------------
 
 def pm25_to_aqi_category(pm25: float) -> str:
@@ -138,15 +106,15 @@ def pm25_to_aqi_category(pm25: float) -> str:
 
 
 # -------------------------
-# FORECAST LOGIC
+# FORECAST LOGIC (lag-aware model)
 # -------------------------
 
-def generate_forecast(model_version: str, sensor_internal: str, days: int) -> str:
+def generate_forecast(sensor_internal: str, days: int) -> str | None:
     """
-    Generate forecast PNG path for given model + sensor.
-    Returns path to saved PNG.
+    Generate forecast PNG path for given sensor.
+    Returns path to saved PNG or None if no data.
     """
-    resources = get_resources(model_version)
+    resources = get_resources()
     model = resources["model"]
     weather_fg = resources["weather_fg"]
     project = resources["project"]
@@ -157,63 +125,48 @@ def generate_forecast(model_version: str, sensor_internal: str, days: int) -> st
     df_future = weather_fg.read().sort_values("date")
     df_future["date"] = pd.to_datetime(df_future["date"]).dt.date
 
-    # For v2 we also need PM2.5 history for this sensor
+    # PM2.5 history for this sensor
     aq_fg = project.get_feature_store().get_feature_group("air_quality", version=1)
     aq_df = aq_fg.read()
     aq_df["date"] = pd.to_datetime(aq_df["date"]).dt.date
     aq_df = aq_df[aq_df["sensor"] == sensor_internal].sort_values("date")
 
+    if aq_df.empty:
+        return None
+
+    pm25_history = list(aq_df["pm25"].values[-3:])
+    if len(pm25_history) < 3:
+        # Not enough history, bail gracefully
+        return None
+
     preds = []
 
-    if model_version == "v1":
-        for offset in range(1, days + 1):
-            target_date = today + timedelta(days=offset)
-            row = df_future[df_future["date"] == target_date]
-            if len(row) == 0:
-                continue
-
-            X = row[[
-                "temperature_2m_mean",
-                "precipitation_sum",
-                "wind_speed_10m_max",
-                "wind_direction_10m_dominant",
-            ]]
-            pred = float(model.predict(X)[0])
-            preds.append({"date": target_date, "predicted_pm25": pred})
-
-    elif model_version == "v2":
-        pm25_history = list(aq_df["pm25"].values[-3:])
-        if len(pm25_history) < 3:
-            # Not enough history, bail gracefully
-            return None
-
-        for offset in range(1, days + 1):
-            target_date = today + timedelta(days=offset)
-            row = df_future[df_future["date"] == target_date]
-            if len(row) == 0:
-                continue
-
-            lag1, lag2, lag3 = pm25_history[-1], pm25_history[-2], pm25_history[-3]
-            roll_mean = float(np.mean(pm25_history[-3:]))
-            roll_std = float(np.std(pm25_history[-3:]))
-
-            X = pd.DataFrame({
-                "temperature_2m_mean": [row.iloc[0]["temperature_2m_mean"]],
-                "precipitation_sum": [row.iloc[0]["precipitation_sum"]],
-                "wind_speed_10m_max": [row.iloc[0]["wind_speed_10m_max"]],
-                "wind_direction_10m_dominant": [row.iloc[0]["wind_direction_10m_dominant"]],
-                "pm25_lag1": [lag1],
-                "pm25_lag2": [lag2],
-                "pm25_lag3": [lag3],
-                "pm25_roll3_mean": [roll_mean],
-                "pm25_roll3_std": [roll_std],
-            })
-
-            pred = float(model.predict(X)[0])
-            preds.append({"date": target_date, "predicted_pm25": pred})
-            pm25_history.append(pred)
-    else:
-        raise ValueError("Unknown model version")
+    for offset in range(1, days + 1):
+        target_date = today + timedelta(days=offset)
+        row = df_future[df_future["date"] == target_date]
+        if len(row) == 0:
+            # no weather data for that date
+            continue
+
+        lag1, lag2, lag3 = pm25_history[-1], pm25_history[-2], pm25_history[-3]
+        roll_mean = float(np.mean(pm25_history[-3:]))
+        roll_std = float(np.std(pm25_history[-3:]))
+
+        X = pd.DataFrame({
+            "temperature_2m_mean": [row.iloc[0]["temperature_2m_mean"]],
+            "precipitation_sum": [row.iloc[0]["precipitation_sum"]],
+            "wind_speed_10m_max": [row.iloc[0]["wind_speed_10m_max"]],
+            "wind_direction_10m_dominant": [row.iloc[0]["wind_direction_10m_dominant"]],
+            "pm25_lag1": [lag1],
+            "pm25_lag2": [lag2],
+            "pm25_lag3": [lag3],
+            "pm25_roll3_mean": [roll_mean],
+            "pm25_roll3_std": [roll_std],
+        })
+
+        pred = float(model.predict(X)[0])
+        preds.append({"date": target_date, "predicted_pm25": pred})
+        pm25_history.append(pred)
 
     if not preds:
         return None
@@ -235,17 +188,16 @@ def generate_forecast(model_version: str, sensor_internal: str, days: int) -> st
 
 
 # -------------------------
-# HINDCAST LOGIC
+# HINDCAST LOGIC (lag-aware model)
 # -------------------------
 
-def generate_hindcast(model_version: str, sensor_internal: str, days: int) -> str:
+def generate_hindcast(sensor_internal: str, days: int) -> str | None:
     """
-    Generate hindcast PNG path for given model + sensor.
-    Returns path to saved PNG.
+    Generate hindcast PNG path for given sensor.
+    Returns path to saved PNG or None if no data.
     """
-    resources = get_resources(model_version)
+    resources = get_resources()
     model = resources["model"]
-    fv = resources["fv"]
     weather_fg = resources["weather_fg"]
     project = resources["project"]
 
@@ -273,72 +225,35 @@ def generate_hindcast(model_version: str, sensor_internal: str, days: int) -> st
     if aq_df.empty:
         return None
 
-    if model_version == "v1":
-        # Use feature view training data + actual pm25
-        features_df, _ = fv.training_data(
-            start_time=start_date,
-            end_time=end_date,
-            statistics_config=False,
-        )
-        features_df["date"] = pd.to_datetime(features_df["date"]).dt.date
+    # Merge weather + actual pm25
+    df = pd.merge(weather_df, aq_df, on="date")
+    if df.empty:
+        return None
 
-        # Filter by sensor if it exists in fv
-        if "sensor" in features_df.columns:
-            features_df = features_df[features_df["sensor"] == sensor_internal]
+    df["pm25_lag1"] = df["pm25"].shift(1)
+    df["pm25_lag2"] = df["pm25"].shift(2)
+    df["pm25_lag3"] = df["pm25"].shift(3)
+    df["pm25_roll3_mean"] = df["pm25"].rolling(3).mean()
+    df["pm25_roll3_std"] = df["pm25"].rolling(3).std()
 
-        merged = pd.merge(
-            features_df,
-            aq_df[["date", "pm25"]],
-            on="date",
-            how="inner",
-        )
+    df = df.dropna().tail(days)
+    if df.empty:
+        return None
 
-        if merged.empty:
-            return None
-
-        X = merged[[
-            "temperature_2m_mean",
-            "precipitation_sum",
-            "wind_speed_10m_max",
-            "wind_direction_10m_dominant",
-        ]]
-        merged["predicted_pm25"] = model.predict(X)
-
-        df_hind = merged
-
-    elif model_version == "v2":
-        # Merge weather + actual pm25
-        df = pd.merge(weather_df, aq_df, on="date")
-        if df.empty:
-            return None
-
-        df["pm25_lag1"] = df["pm25"].shift(1)
-        df["pm25_lag2"] = df["pm25"].shift(2)
-        df["pm25_lag3"] = df["pm25"].shift(3)
-        df["pm25_roll3_mean"] = df["pm25"].rolling(3).mean()
-        df["pm25_roll3_std"] = df["pm25"].rolling(3).std()
-
-        df = df.dropna().tail(days)
-        if df.empty:
-            return None
-
-        X = df[[
-            "temperature_2m_mean",
-            "precipitation_sum",
-            "wind_speed_10m_max",
-            "wind_direction_10m_dominant",
-            "pm25_lag1",
-            "pm25_lag2",
-            "pm25_lag3",
-            "pm25_roll3_mean",
-            "pm25_roll3_std",
-        ]]
-
-        df["predicted_pm25"] = model.predict(X)
-        df_hind = df
-
-    else:
-        raise ValueError("Unknown model version")
+    X = df[[
+        "temperature_2m_mean",
+        "precipitation_sum",
+        "wind_speed_10m_max",
+        "wind_direction_10m_dominant",
+        "pm25_lag1",
+        "pm25_lag2",
+        "pm25_lag3",
+        "pm25_roll3_mean",
+        "pm25_roll3_std",
+    ]]
+
+    df["predicted_pm25"] = model.predict(X)
+    df_hind = df
 
     tmp_path = tempfile.NamedTemporaryFile(suffix=".png", delete=False).name
     sensor_label = SENSOR_LABELS[sensor_internal]
@@ -355,20 +270,18 @@ def generate_hindcast(model_version: str, sensor_internal: str, days: int) -> st
 
 
 # -------------------------
-# GRADIO UI (MAX VIBES)
+# GRADIO UI (MAX VIBES, SINGLE MODEL)
 # -------------------------
 
-def run_dashboard(sensor_display: str, model_choice: str, forecast_days: int, hindcast_days: int):
+def run_dashboard(sensor_display: str, forecast_days: int, hindcast_days: int):
     try:
         sensor_internal = DISPLAY_TO_INTERNAL[sensor_display]
     except KeyError:
         return None, None, f"Unknown sensor: {sensor_display}"
 
-    model_version = "v1" if "v1" in model_choice else "v2"
-
     try:
-        forecast_path = generate_forecast(model_version, sensor_internal, forecast_days)
-        hindcast_path = generate_hindcast(model_version, sensor_internal, hindcast_days)
+        forecast_path = generate_forecast(sensor_internal, forecast_days)
+        hindcast_path = generate_hindcast(sensor_internal, hindcast_days)
     except Exception as e:
         # Don't explode the UI; show error text and empty images
         return None, None, f"⚠️ Something went wrong: {str(e)}"
@@ -376,12 +289,10 @@ def run_dashboard(sensor_display: str, model_choice: str, forecast_days: int, hi
     if forecast_path is None and hindcast_path is None:
         return None, None, "No data available for this sensor/time range yet."
 
-    # Simple AQI summary from latest forecast
     summary_text = ""
     if forecast_path is not None:
-        # We don't have the df here anymore, so just show generic text
         summary_text = (
-            f"✅ Forecast generated for **{sensor_display}** using **{model_choice}**.\n\n"
+            f"✅ Forecast generated for **{sensor_display}** using the lag-aware Dundee PM2.5 model.\n\n"
             f"City: **{CITY_NAME}**  \n"
             f"Last updated: **{datetime.utcnow().strftime('%Y-%m-%d %H:%M UTC')}**"
         )
@@ -393,9 +304,9 @@ with gr.Blocks(theme="soft") as demo:
     gr.Markdown(
         """
         # 🌤️ Dundee Air Quality Dashboard  
-        Compare air quality forecasts and hindcasts for different sensors across Dundee.
+        Lag-aware PM2.5 forecasts and hindcasts for Dundee’s air quality sensors.
 
-        Select a **sensor**, choose a **model**, set your horizons, and hit **Update**.
+        Select a **sensor**, set your horizons, and hit **Update**.
         """
     )
 
@@ -406,11 +317,6 @@ with gr.Blocks(theme="soft") as demo:
             label="Sensor",
             info="Choose which sensor in Dundee to analyze.",
         )
-        model_radio = gr.Radio(
-            choices=["Model v1 (no lag features)", "Model v2 (lag-aware)"],
-            value="Model v2 (lag-aware)",
-            label="Model",
-        )
 
     with gr.Row():
         forecast_days_slider = gr.Slider(
@@ -438,7 +344,7 @@ with gr.Blocks(theme="soft") as demo:
 
     update_btn.click(
         fn=run_dashboard,
-        inputs=[sensor_dropdown, model_radio, forecast_days_slider, hindcast_days_slider],
+        inputs=[sensor_dropdown, forecast_days_slider, hindcast_days_slider],
         outputs=[forecast_img, hindcast_img, summary_box],
     )