Improve predictor plots and feature importance view

app.py

@@ -7,7 +7,7 @@ import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
 
-from predictor.inference import predict_pair
+from predictor.inference import get_group_importance, predict_pair
 
 EXAMPLE_SIRNA = "ACUUUUUCGCGGUUGUUAC"
 EXAMPLE_TARGET = "GUAACAACCGCGAAAAAGU"
@@ -30,26 +30,54 @@ def _pairing_status(sirna: str, mrna: str) -> list[str]:
 
 
 def make_pairing_plot(sirna: str, mrna: str):
-    statuses = _pairing_status(sirna, mrna)
+    target_display = mrna[::-1]
+    statuses = _pairing_status(sirna, target_display)
     colors = {"WC": "#2E8B57", "Wobble": "#E09F3E", "Mismatch": "#C0392B"}
     fig, ax = plt.subplots(figsize=(12, 2.8))
     x = np.arange(len(statuses))
+    ax.axvspan(0.5, 7.5, color="#EAF4EC", alpha=0.9, zorder=0)
     for i, status in enumerate(statuses):
         ax.plot([i, i], [0.35, 0.65], color=colors[status], linewidth=3)
         ax.text(i, 0.1, sirna[i], ha="center", va="center", fontsize=10, fontweight="bold")
-        ax.text(i, 0.9, mrna[i], ha="center", va="center", fontsize=10, fontweight="bold")
+        ax.text(i, 0.9, target_display[i], ha="center", va="center", fontsize=10, fontweight="bold")
         ax.text(i, 0.5, "•" if status != "WC" else "|", ha="center", va="center", color=colors[status], fontsize=14)
-    ax.set_xlim(-0.7, len(statuses) - 0.3)
-    ax.set_ylim(0, 1)
+    ax.text(-0.85, 0.1, "5'", ha="center", va="center", fontsize=10, fontweight="bold")
+    ax.text(len(statuses) - 0.15, 0.1, "3'", ha="center", va="center", fontsize=10, fontweight="bold")
+    ax.text(-0.85, 0.9, "3'", ha="center", va="center", fontsize=10, fontweight="bold")
+    ax.text(len(statuses) - 0.15, 0.9, "5'", ha="center", va="center", fontsize=10, fontweight="bold")
+    ax.text(3.9, 1.03, "seed region (2-8)", ha="center", va="center", fontsize=9, color="#496A51")
+    ax.set_xlim(-1.1, len(statuses) - 0.1)
+    ax.set_ylim(0, 1.08)
     ax.set_xticks(x)
     ax.set_xticklabels([str(i + 1) for i in x], fontsize=8)
     ax.set_yticks([])
-    ax.set_title("Pairing Summary (siRNA bottom, mRNA top)")
+    ax.set_title("Antiparallel Pairing Summary")
     ax.grid(axis="x", alpha=0.2)
     fig.tight_layout()
     return fig
 
 
+def make_prediction_plot(pred_row: dict):
+    labels = ["XGBoost", "LightGBM", "Average", "Calibrated"]
+    values = [
+        float(pred_row["xgb_pred"]),
+        float(pred_row["lgb_pred"]),
+        float(pred_row["avg_pred"]),
+        float(pred_row["prediction"]),
+    ]
+    colors = ["#4472C4", "#70AD47", "#A5A5A5", "#C55A11"]
+    fig, ax = plt.subplots(figsize=(7.2, 3.8))
+    bars = ax.bar(labels, values, color=colors, width=0.65)
+    for bar, value in zip(bars, values):
+        ax.text(bar.get_x() + bar.get_width() / 2, value + 0.02, f"{value:.3f}", ha="center", va="bottom", fontsize=9)
+    ax.set_ylim(0, 1.05)
+    ax.set_ylabel("Predicted efficacy")
+    ax.set_title("Prediction Breakdown")
+    ax.grid(axis="y", alpha=0.25)
+    fig.tight_layout()
+    return fig
+
+
 def make_energy_plot(feature_row: dict):
     dg = [feature_row[f"DG_pos{i}"] for i in range(1, 19)]
     dh = [feature_row[f"DH_pos{i}"] for i in range(1, 19)]
@@ -67,6 +95,20 @@ def make_energy_plot(feature_row: dict):
     return fig
 
 
+def make_group_importance_plot(importance_df: pd.DataFrame):
+    display_df = importance_df.sort_values("ensemble_importance", ascending=True).copy()
+    values = display_df["ensemble_importance"].to_numpy(dtype=float) * 100.0
+    fig, ax = plt.subplots(figsize=(7.2, 4.2))
+    bars = ax.barh(display_df["group"], values, color="#5B8E7D")
+    for bar, value in zip(bars, values):
+        ax.text(value + 0.15, bar.get_y() + bar.get_height() / 2, f"{value:.1f}%", va="center", fontsize=9)
+    ax.set_xlabel("Normalized global importance (%)")
+    ax.set_title("Global Feature-Group Importance")
+    ax.grid(axis="x", alpha=0.25)
+    fig.tight_layout()
+    return fig
+
+
 def make_summary_markdown(pred_row: dict) -> str:
     agreement_gap = abs(float(pred_row["xgb_pred"]) - float(pred_row["lgb_pred"]))
     return f"""
@@ -100,6 +142,7 @@ def run_single_prediction(sirna_seq: str, target_seq: str, cell_line: str):
         raise gr.Error("Both siRNA and mRNA target-window sequences are required.")
     try:
         pred_row, feature_row = predict_pair(sirna_seq, target_seq, source="unknown", cell_line=cell_line)
+        importance_df = get_group_importance()
     except Exception as exc:
         raise gr.Error(str(exc)) from exc
     summary = make_summary_markdown(pred_row)
@@ -113,9 +156,11 @@ def run_single_prediction(sirna_seq: str, target_seq: str, cell_line: str):
         columns=["score", "value"],
     )
     feature_table = build_feature_table(feature_row)
+    prediction_fig = make_prediction_plot(pred_row)
     pairing_fig = make_pairing_plot(pred_row["siRNA_clean"], pred_row["mRNA_clean"])
     energy_fig = make_energy_plot(feature_row)
-    return summary, score_table, feature_table, pairing_fig, energy_fig
+    importance_fig = make_group_importance_plot(importance_df)
+    return summary, score_table, feature_table, prediction_fig, pairing_fig, energy_fig, importance_fig
 
 
 def create_app():
@@ -153,15 +198,17 @@ def create_app():
 
             with gr.Column(scale=2):
                 summary_output = gr.Markdown()
-                score_output = gr.Dataframe(label="Model outputs", interactive=False)
-                feature_output = gr.Dataframe(label="Selected engineered features", interactive=False)
+                score_output = gr.Dataframe(label="Prediction values", interactive=False)
+                feature_output = gr.Dataframe(label="Key thermodynamic features", interactive=False)
+                prediction_output = gr.Plot(label="Prediction breakdown")
                 pairing_output = gr.Plot(label="Pairing summary")
                 energy_output = gr.Plot(label="Thermodynamic profiles")
+                importance_output = gr.Plot(label="Global feature-group importance")
 
         predict_btn.click(
             fn=run_single_prediction,
             inputs=[sirna_input, target_input, cell_line_input],
-            outputs=[summary_output, score_output, feature_output, pairing_output, energy_output],
+            outputs=[summary_output, score_output, feature_output, prediction_output, pairing_output, energy_output, importance_output],
         )
 
     return demo

predictor/inference.py

@@ -52,6 +52,94 @@ def load_artifacts(repo_id: str | None = None, local_dir: str | Path | None = No
     return _load_artifacts_cached(repo_id, local_dir_str)
 
 
+def _normalize_importance(values: np.ndarray) -> np.ndarray:
+    arr = np.asarray(values, dtype=float)
+    total = float(arr.sum())
+    if total <= 0:
+        return np.zeros_like(arr, dtype=float)
+    return arr / total
+
+
+def _xgb_importance_array(xgb_model, n_features: int) -> np.ndarray:
+    try:
+        arr = np.asarray(xgb_model.feature_importances_, dtype=float)
+        if arr.size == n_features:
+            return arr
+    except Exception:
+        pass
+
+    arr = np.zeros(n_features, dtype=float)
+    try:
+        score = xgb_model.get_booster().get_score(importance_type="gain")
+        for key, value in score.items():
+            if key.startswith("f"):
+                idx = int(key[1:])
+                if 0 <= idx < n_features:
+                    arr[idx] = float(value)
+    except Exception:
+        pass
+    return arr
+
+
+def _lgb_importance_array(lgb_model, n_features: int) -> np.ndarray:
+    arr = np.asarray(lgb_model.feature_importance(importance_type="gain"), dtype=float)
+    if arr.size < n_features:
+        arr = np.pad(arr, (0, n_features - arr.size))
+    elif arr.size > n_features:
+        arr = arr[:n_features]
+    return arr
+
+
+def _feature_group(feature_name: str) -> str:
+    if feature_name.startswith("siRNA_pos"):
+        return "siRNA sequence"
+    if feature_name.startswith("mRNA_pos"):
+        return "target sequence"
+    if feature_name.startswith("inter_") or feature_name in {
+        "total_wc",
+        "total_wobble",
+        "total_mismatch",
+        "seed_wc",
+        "seed_wobble",
+    }:
+        return "pairing"
+    if feature_name.startswith("si_mono_") or feature_name.startswith("si_di_") or feature_name.startswith("mr_mono_") or feature_name.startswith("mr_di_"):
+        return "k-mer composition"
+    if feature_name.startswith("source_") or feature_name.startswith("cell_line_"):
+        return "metadata"
+    return "thermodynamics"
+
+
+def get_group_importance(repo_id: str | None = None, local_dir: str | Path | None = None) -> pd.DataFrame:
+    _, _, feature_names, xgb_model, lgb_model, _ = load_artifacts(repo_id=repo_id, local_dir=local_dir)
+    if not feature_names:
+        raise ValueError("Feature names are unavailable in feature_artifacts.json")
+
+    n_features = len(feature_names)
+    xgb_arr = _normalize_importance(_xgb_importance_array(xgb_model, n_features))
+    lgb_arr = _normalize_importance(_lgb_importance_array(lgb_model, n_features))
+    ensemble_arr = (xgb_arr + lgb_arr) / 2.0
+
+    rows = []
+    for feature_name, xgb_val, lgb_val, ensemble_val in zip(feature_names, xgb_arr, lgb_arr, ensemble_arr):
+        rows.append(
+            {
+                "group": _feature_group(feature_name),
+                "xgb_importance": float(xgb_val),
+                "lgb_importance": float(lgb_val),
+                "ensemble_importance": float(ensemble_val),
+            }
+        )
+
+    grouped = (
+        pd.DataFrame(rows)
+        .groupby("group", as_index=False)[["xgb_importance", "lgb_importance", "ensemble_importance"]]
+        .sum()
+        .sort_values("ensemble_importance", ascending=False)
+    )
+    return grouped
+
+
 def prepare_dataframe(df: pd.DataFrame, numeric_cols: list[str]) -> pd.DataFrame:
     work_df = df.copy()
     if "siRNA" not in work_df.columns or "mRNA" not in work_df.columns: