Upload 11 files

.gitattributes

@@ -33,3 +33,11 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+ensemble_model_AGVHD.skops filter=lfs diff=lfs merge=lfs -text
+ensemble_model_CGVHD.skops filter=lfs diff=lfs merge=lfs -text
+ensemble_model_DEAD.skops filter=lfs diff=lfs merge=lfs -text
+ensemble_model_DWOGF.skops filter=lfs diff=lfs merge=lfs -text
+ensemble_model_GF.skops filter=lfs diff=lfs merge=lfs -text
+ensemble_model_STROKEHI.skops filter=lfs diff=lfs merge=lfs -text
+ensemble_model_VOCPSHI.skops filter=lfs diff=lfs merge=lfs -text
+preprocessor.skops filter=lfs diff=lfs merge=lfs -text

app (2).py

@@ -0,0 +1,476 @@
+import gradio as gr
+import pandas as pd
+import traceback
+
+from inference import (
+    FEATURE_NAMES,
+    REPORTING_OUTCOMES,
+    OUTCOME_DESCRIPTIONS,
+    OUTCOMES,
+    SHAP_OUTCOMES,
+    predict_with_comparison,
+    create_all_shap_plots,
+    icon_array,
+)
+
+
+# ---------------------------------------------------------------------------
+# Choice lists
+# ---------------------------------------------------------------------------
+
+AGEGPFF_CHOICES   = ["<=10", "11-17", "18-29", "30-49", ">=50"]
+SEX_CHOICES       = ["Male", "Female"]
+KPS_CHOICES       = ["<90", "≥ 90"]
+DONORF_CHOICES    = [
+    "HLA identical sibling",
+    "HLA mismatch relative",
+    "Matched unrelated donor",
+    "Mismatched unrelated donor or cord blood",
+]
+GRAFTYPE_CHOICES  = ["Bone marrow", "Peripheral blood", "Cord blood"]
+CONDGRPF_CHOICES  = ["MAC", "RIC", "NMA"]
+CONDGRP_FINAL_CHOICES = [
+    "TBI/Cy", "TBI/Cy/Flu", "TBI/Cy/Flu/TT", "TBI/Mel", "TBI/Flu",
+    "TBI alone (300/400/600cGy)", "Bu/Cy", "Bu/Mel", "Flu/Bu/TT",
+    "Flu/Bu", "Flu/Mel/TT", "Flu/Mel", "Cy/Flu", "Treosulfan",
+    "Cy alone", "Flud", "TLI",
+]
+ATGF_CHOICES      = ["ATG", "Alemtuzumab", "None"]
+GVHD_FINAL_CHOICES = [
+    "Ex-vivo T-cell depletion", "CD34 selection", "Post-CY + siro +- MMF",
+    "Post-CY + MMF + CNI", "CNI + MMF", "CNI + MTX", "CNI alone",
+    "CNI + siro", "Siro alone", "MMF + MTX", "MMF + siro", "MMF alone",
+    "MTX alone", "MTX + siro",
+]
+HLA_FINAL_CHOICES = ["8/8", "7/8", "≤ 6/8"]
+RCMVPR_CHOICES    = ["Negative", "Positive"]
+EXCHTFPR_CHOICES  = ["No", "Yes"]
+VOC2YPR_CHOICES   = ["No", "Yes"]
+VOCFRQPR_CHOICES  = ["< 3/yr", "≥ 3/yr"]
+SCATXRSN_CHOICES  = [
+    "CNS event", "Acute chest Syndrome", "Recurrent vaso-occlusive pain",
+    "Recurrent priapism", "Excessive transfusion requirements/iron overload",
+    "Cardio-pulmonary", "Chronic transfusion", "Asymptomatic",
+    "Renal insufficiency", "Splenic sequestration", "Avascular necrosis",
+    "Hodgkin lymphoma",
+]
+
+
+# ---------------------------------------------------------------------------
+# Grouped published-regimen dropdown
+# ---------------------------------------------------------------------------
+
+GROUPED_REGIMEN_CHOICES = [
+    ("── HLA IDENTICAL ──",                        "__header_hla_identical__"),
+    ("Hsieh et al 2014",                           "Hsieh et al 2014"),
+    ("Krishnamurti et al 2019",                    "Krishnamurti et al 2019"),
+    ("King et al 2015",                            "King et al 2015"),
+    ("Walters et al 1996",                         "Walters et al 1996"),
+    ("── HLA MISMATCHED ──",                       "__header_hla_mismatched__"),
+    ("Bolanos-Meade et al 2022 (HLA Mismatch)",    "Bolanos-Meade et al 2022 (HLA Mismatch)"),
+    ("Patel et al 2020 (HLA Mismatch)",            "Patel et al 2020 (HLA Mismatch)"),
+    ("── MATCHED UNRELATED ──",                    "__header_matched_unrelated__"),
+    ("L Krishnamurti et al 2019",                  "L Krishnamurti et al 2019"),
+    ("Shenoy et al 2016",                          "Shenoy et al 2016"),
+    ("── MISMATCHED UNRELATED / CORD BLOOD ──",    "__header_mismatched_cord__"),
+    ("Bolanos-Meade et al 2022 (Mismatched/Cord)", "Bolanos-Meade et al 2022 (Mismatched/Cord)"),
+    ("Patel et al 2020 (Mismatched/Cord)",         "Patel et al 2020 (Mismatched/Cord)"),
+]
+
+HEADER_VALUES = {v for _, v in GROUPED_REGIMEN_CHOICES if v.startswith("__header_")}
+
+PUBLISHED_PRESETS = {
+    # HLA Identical Sibling
+    "Hsieh et al 2014": {
+        "CONDGRPF": "NMA", "CONDGRP_FINAL": "TBI alone (300/400/600cGy)",
+        "ATGF": "Alemtuzumab", "GVHD_FINAL": "Siro alone",
+        "HLA_FINAL": "8/8", "DONORF": "HLA identical sibling",
+    },
+    "Krishnamurti et al 2019": {
+        "CONDGRPF": "MAC", "CONDGRP_FINAL": "Flu/Bu",
+        "ATGF": "ATG", "GVHD_FINAL": "CNI + MTX",
+        "HLA_FINAL": "8/8", "DONORF": "HLA identical sibling",
+    },
+    "King et al 2015": {
+        "CONDGRPF": "RIC", "CONDGRP_FINAL": "Flu/Mel",
+        "ATGF": "Alemtuzumab", "GVHD_FINAL": "CNI + MTX",
+        "HLA_FINAL": "8/8", "DONORF": "HLA identical sibling",
+    },
+    "Walters et al 1996": {
+        "CONDGRPF": "MAC", "CONDGRP_FINAL": "Bu/Cy",
+        "ATGF": "ATG", "GVHD_FINAL": "CNI + MTX",
+        "HLA_FINAL": "8/8", "DONORF": "HLA identical sibling",
+    },
+    # HLA Mismatch Relative
+    "Bolanos-Meade et al 2022 (HLA Mismatch)": {
+        "CONDGRPF": "NMA", "CONDGRP_FINAL": "TBI/Cy/Flu",
+        "ATGF": "ATG", "GVHD_FINAL": "Post-CY + siro +- MMF",
+        "HLA_FINAL": "7/8", "DONORF": "HLA mismatch relative",
+    },
+    "Patel et al 2020 (HLA Mismatch)": {
+        "CONDGRPF": "NMA", "CONDGRP_FINAL": "TBI/Cy/Flu/TT",
+        "ATGF": "ATG", "GVHD_FINAL": "Post-CY + siro +- MMF",
+        "HLA_FINAL": "7/8", "DONORF": "HLA mismatch relative",
+    },
+    # Matched Unrelated Donor
+    "L Krishnamurti et al 2019": {
+        "CONDGRPF": "MAC", "CONDGRP_FINAL": "Flu/Bu",
+        "ATGF": "ATG", "GVHD_FINAL": "CNI + MTX",
+        "HLA_FINAL": "8/8", "DONORF": "Matched unrelated donor",
+    },
+    "Shenoy et al 2016": {
+        "CONDGRPF": "RIC", "CONDGRP_FINAL": "Flu/Mel",
+        "ATGF": "Alemtuzumab", "GVHD_FINAL": "CNI + MTX",
+        "HLA_FINAL": "8/8", "DONORF": "Matched unrelated donor",
+    },
+    # Mismatched Unrelated Donor or Cord Blood
+    "Bolanos-Meade et al 2022 (Mismatched/Cord)": {
+        "CONDGRPF": "NMA", "CONDGRP_FINAL": "TBI/Cy/Flu",
+        "ATGF": "ATG", "GVHD_FINAL": "Post-CY + siro +- MMF",
+        "HLA_FINAL": "7/8", "DONORF": "Mismatched unrelated donor or cord blood",
+    },
+    "Patel et al 2020 (Mismatched/Cord)": {
+        "CONDGRPF": "NMA", "CONDGRP_FINAL": "TBI/Cy/Flu/TT",
+        "ATGF": "ATG", "GVHD_FINAL": "Post-CY + siro +- MMF",
+        "HLA_FINAL": "7/8", "DONORF": "Mismatched unrelated donor or cord blood",
+    },
+}
+
+
+# ---------------------------------------------------------------------------
+# Feature groupings
+# ---------------------------------------------------------------------------
+
+PATIENT_FEATURES = ["AGE", "AGEGPFF", "SEX", "KPS", "RCMVPR"]
+DONOR_FEATURES   = ["DONORF", "GRAFTYPE", "HLA_FINAL",
+                    "CONDGRPF", "CONDGRP_FINAL", "ATGF", "GVHD_FINAL"]
+DISEASE_FEATURES = ["NACS2YR", "EXCHTFPR", "VOC2YPR", "VOCFRQPR", "SCATXRSN"]
+ALL_FEATURES     = PATIENT_FEATURES + DONOR_FEATURES + DISEASE_FEATURES
+
+
+# ---------------------------------------------------------------------------
+# Utility callbacks
+# ---------------------------------------------------------------------------
+
+def get_age_group(age):
+    if age is None or age == "":
+        return ""
+    try:
+        age = float(age)
+        if age <= 10:
+            return "<=10"
+        elif age <= 17:
+            return "11-17"
+        elif age <= 29:
+            return "18-29"
+        elif age <= 49:
+            return "30-49"
+        else:
+            return ">=50"
+    except (ValueError, TypeError):
+        return ""
+
+
+def vocfrqpr_from_voc2ypr(voc_status):
+    if voc_status == "No":
+        return gr.update(value="< 3/yr", interactive=False)
+    else:
+        return gr.update(value=None, interactive=True)
+
+
+def apply_grouped_preset(selected_value):
+    if not selected_value or selected_value in HEADER_VALUES:
+        return [gr.update(value=None)] + [gr.update()] * 6
+
+    preset = PUBLISHED_PRESETS.get(selected_value)
+    if not preset:
+        return [gr.update()] * 7
+
+    return [
+        gr.update(),
+        gr.update(value=preset["DONORF"]),
+        gr.update(value=preset["CONDGRPF"]),
+        gr.update(value=preset["CONDGRP_FINAL"]),
+        gr.update(value=preset["ATGF"]),
+        gr.update(value=preset["GVHD_FINAL"]),
+        gr.update(value=preset["HLA_FINAL"]),
+    ]
+
+
+# ---------------------------------------------------------------------------
+# Component factory
+# ---------------------------------------------------------------------------
+
+def make_component(name: str):
+    if name == "AGE":
+        return gr.Number(label="Age at transplant (years)", minimum=0, maximum=120)
+    elif name == "AGEGPFF":
+        return gr.Textbox(label="Age group (Auto-filled)", interactive=False)
+    elif name == "NACS2YR":
+        return gr.Number(
+            label="Number of Acute Chest Syndromes within 2 years pre-HCT",
+            minimum=0,
+        )
+    elif name == "SEX":
+        return gr.Dropdown(SEX_CHOICES, label="Sex")
+    elif name == "KPS":
+        return gr.Dropdown(KPS_CHOICES, label="Karnofsky/Lansky Performance Score at HCT")
+    elif name == "DONORF":
+        return gr.Dropdown(DONORF_CHOICES, label="Donor type")
+    elif name == "GRAFTYPE":
+        return gr.Dropdown(GRAFTYPE_CHOICES, label="Graft type")
+    elif name == "CONDGRPF":
+        return gr.Dropdown(CONDGRPF_CHOICES, label="Conditioning intensity")
+    elif name == "CONDGRP_FINAL":
+        return gr.Dropdown(CONDGRP_FINAL_CHOICES, label="Conditioning Regimen")
+    elif name == "ATGF":
+        return gr.Dropdown(ATGF_CHOICES, label="Serotherapy")
+    elif name == "GVHD_FINAL":
+        return gr.Dropdown(GVHD_FINAL_CHOICES, label="GVHD Prophylaxis")
+    elif name == "HLA_FINAL":
+        return gr.Dropdown(HLA_FINAL_CHOICES, label="Donor-Recipient HLA Matching")
+    elif name == "RCMVPR":
+        return gr.Dropdown(RCMVPR_CHOICES, label="Recipient CMV serostatus")
+    elif name == "EXCHTFPR":
+        return gr.Dropdown(EXCHTFPR_CHOICES, label="Exchange transfusion required?")
+    elif name == "VOC2YPR":
+        return gr.Dropdown(
+            VOC2YPR_CHOICES,
+            label="VOC requiring hospitalization within 2 years pre-HCT?",
+        )
+    elif name == "VOCFRQPR":
+        return gr.Dropdown(VOCFRQPR_CHOICES, label="Frequency of VOC hospitalizations")
+    elif name == "SCATXRSN":
+        return gr.Dropdown(SCATXRSN_CHOICES, label="Reason for Transplant")
+    else:
+        return gr.Textbox(label=name)
+
+
+# ---------------------------------------------------------------------------
+# Prediction callback
+# ---------------------------------------------------------------------------
+
+def predict_gradio(*values):
+    try:
+        user_vals = {f: v for f, v in zip(ALL_FEATURES, values)}
+
+        missing = []
+        for f, v in user_vals.items():
+            if v is None or v == "" or (isinstance(v, float) and pd.isna(v)):
+                missing.append(f)
+        if missing:
+            raise ValueError(
+                f"Please fill in all fields before predicting.\nMissing: {', '.join(missing)}"
+            )
+
+        calibrated, uncalibrated = predict_with_comparison(user_vals)
+        calibrated_probs, calibrated_intervals = calibrated
+
+        rows = []
+        for outcome in REPORTING_OUTCOMES:
+            desc       = OUTCOME_DESCRIPTIONS[outcome]
+            calib_prob = calibrated_probs[outcome]
+            ci_low_c, ci_high_c = calibrated_intervals[outcome]
+            rows.append({
+                "Outcome":     desc,
+                "Probability": f"{calib_prob * 100:.1f}%",
+                "95% CI":      f"[{ci_low_c * 100:.1f}% - {ci_high_c * 100:.1f}%]",
+            })
+        df = pd.DataFrame(rows)
+
+        shap_plots = create_all_shap_plots(user_vals, max_display=10)
+
+        # Icon arrays for each outcome
+        icon_outcomes = ["DEAD", "GF", "AGVHD", "CGVHD", "VOCPSHI", "STROKEHI"]
+        icon_plots = {o: icon_array(calibrated_probs[o], o) for o in icon_outcomes}
+
+        return (
+            df,
+            icon_plots["DEAD"],
+            icon_plots["GF"],
+            icon_plots["AGVHD"],
+            icon_plots["CGVHD"],
+            icon_plots["VOCPSHI"],
+            icon_plots["STROKEHI"],
+            shap_plots["DEAD"],
+            shap_plots["GF"],
+            shap_plots["AGVHD"],
+            shap_plots["CGVHD"],
+            shap_plots["VOCPSHI"],
+            shap_plots["EFS"],
+            shap_plots["STROKEHI"],
+            shap_plots["OS"],
+        )
+
+    except Exception as e:
+        tb = traceback.format_exc()
+        print("=" * 60)
+        print("ERROR IN predict_gradio:")
+        print(tb)
+        print("=" * 60)
+        raise gr.Error(f"{type(e).__name__}: {str(e)}\n\nSee terminal for full traceback.")
+
+
+# ---------------------------------------------------------------------------
+# CSS  (passed to launch() in Gradio 6+)
+# ---------------------------------------------------------------------------
+
+custom_css = """
+.predict-button {
+    background: linear-gradient(to right, #ff6b35, #ff8c42) !important;
+    border: none !important;
+    color: white !important;
+    font-weight: bold !important;
+    font-size: 16px !important;
+    padding: 12px !important;
+}
+.predict-button:hover {
+    background: linear-gradient(to right, #ff5722, #ff7b29) !important;
+}
+"""
+
+# ---------------------------------------------------------------------------
+# Gradio UI
+# ---------------------------------------------------------------------------
+
+with gr.Blocks(title="HCT Outcome Prediction Model") as demo:
+    gr.Markdown(
+        """
+        # HCT Outcome Prediction Model
+
+        Enter patient, transplant, and disease characteristics to predict outcomes.
+        """
+    )
+
+    inputs_dict = {}
+
+    with gr.Row():
+        # ── Patient Characteristics ──────────────────────────────────────
+        with gr.Column(scale=1):
+            gr.Markdown("### Patient Characteristics")
+            for f in PATIENT_FEATURES:
+                inputs_dict[f] = make_component(f)
+
+        # ── Transplant Characteristics ───────────────────────────────────
+        with gr.Column(scale=1):
+            gr.Markdown("### Transplant Characteristics")
+
+            grouped_regimen_dropdown = gr.Dropdown(
+                choices=GROUPED_REGIMEN_CHOICES,
+                value=None,
+                label="Published conditioning regimen",
+                info="Auto-fills Donor Type, Conditioning Intensity, Conditioning Regimen, "
+                     "Serotherapy and GVHD Prophylaxis",
+            )
+
+            donorf_comp   = inputs_dict["DONORF"]        = make_component("DONORF")
+            inputs_dict["GRAFTYPE"]                      = make_component("GRAFTYPE")
+            condgrpf      = inputs_dict["CONDGRPF"]      = make_component("CONDGRPF")
+            condgrp_final = inputs_dict["CONDGRP_FINAL"] = make_component("CONDGRP_FINAL")
+            atgf          = inputs_dict["ATGF"]          = make_component("ATGF")
+            gvhd_final    = inputs_dict["GVHD_FINAL"]    = make_component("GVHD_FINAL")
+            hla_final     = inputs_dict["HLA_FINAL"]     = make_component("HLA_FINAL")
+
+        # ── Disease Characteristics ──────────────────────────────────────
+        with gr.Column(scale=1):
+            gr.Markdown("### Disease Characteristics")
+            for f in DISEASE_FEATURES:
+                inputs_dict[f] = make_component(f)
+
+    # ── Reactive callbacks ───────────────────────────────────────────────
+    inputs_dict["AGE"].change(
+        fn=get_age_group,
+        inputs=inputs_dict["AGE"],
+        outputs=inputs_dict["AGEGPFF"],
+    )
+
+    inputs_dict["VOC2YPR"].change(
+        fn=vocfrqpr_from_voc2ypr,
+        inputs=inputs_dict["VOC2YPR"],
+        outputs=inputs_dict["VOCFRQPR"],
+    )
+
+    grouped_regimen_dropdown.change(
+        fn=apply_grouped_preset,
+        inputs=grouped_regimen_dropdown,
+        outputs=[
+            grouped_regimen_dropdown,
+            donorf_comp, condgrpf, condgrp_final, atgf, gvhd_final, hla_final,
+        ],
+    )
+
+    inputs_list = [inputs_dict[f] for f in ALL_FEATURES]
+
+    btn = gr.Button("Predict", elem_classes="predict-button", size="lg")
+
+    gr.Markdown("---")
+    gr.Markdown("## Prediction Results")
+    gr.Markdown("### Predicted Outcomes")
+
+    with gr.Column():
+        output_table = gr.Dataframe(
+            headers=["Outcome", "Probability", "95% CI"],
+            label="",
+            row_count=(len(REPORTING_OUTCOMES), "dynamic"),
+            column_count=(3, "fixed"),   # fixed: col_count → column_count (Gradio 6)
+        )
+
+    gr.Markdown("---")
+    gr.Markdown("## Icon Arrays")
+
+    with gr.Row():
+        with gr.Column():
+            icon_dead    = gr.Plot(label="Death")
+        with gr.Column():
+            icon_gf      = gr.Plot(label="Graft Failure")
+        with gr.Column():
+            icon_agvhd   = gr.Plot(label="Acute Graft-versus-Host Disease")
+
+    with gr.Row():
+        with gr.Column():
+            icon_cgvhd   = gr.Plot(label="Chronic Graft-versus-Host Disease")
+        with gr.Column():
+            icon_vocpshi = gr.Plot(label="Vaso-Occlusive Crisis Post-HCT")
+        with gr.Column():
+            icon_stroke  = gr.Plot(label="Stroke Post-HCT")
+
+    gr.Markdown("---")
+    gr.Markdown("## SHAP - Feature Importance")
+
+    with gr.Row():
+        with gr.Column():
+            shap_dead   = gr.Plot(label="Death")
+        with gr.Column():
+            shap_gf     = gr.Plot(label="Graft Failure")
+        with gr.Column():
+            shap_agvhd  = gr.Plot(label="Acute Graft-versus-Host Disease")
+        with gr.Column():
+            shap_cgvhd  = gr.Plot(label="Chronic Graft-versus-Host Disease")
+
+    with gr.Row():
+        with gr.Column():
+            shap_vocpshi = gr.Plot(label="Vaso-Occlusive Crisis Post-HCT")
+        with gr.Column():
+            shap_efs     = gr.Plot(label="Event-Free Survival")
+        with gr.Column():
+            shap_stroke  = gr.Plot(label="Stroke Post-HCT")
+        with gr.Column():
+            shap_os      = gr.Plot(label="Overall Survival")
+
+    btn.click(
+        fn=predict_gradio,
+        inputs=inputs_list,
+        outputs=[
+            output_table,
+            icon_dead, icon_gf, icon_agvhd, icon_cgvhd, icon_vocpshi, icon_stroke,
+            shap_dead, shap_gf, shap_agvhd, shap_cgvhd,
+            shap_vocpshi, shap_efs, shap_stroke, shap_os,
+        ],
+    )
+
+
+if __name__ == "__main__":
+    demo.launch(
+        ssr_mode=False,
+        css=custom_css,   # css moved to launch() in Gradio 6
+    )

ensemble_model_AGVHD.skops

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3d82b622617aed90a5925d450ce6ba40909f61f012570566e62c7581b86e9a2e
+size 74999945

ensemble_model_CGVHD.skops

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d05b99633060d90ca94e48b332efd52301d0c87631f8c8c5f638a438bc68aece
+size 92583386

ensemble_model_DEAD.skops

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c5cd000ae7752e4852c3271c9ea434c34830f7e8007ec107b7715833852028ed
+size 66979465

ensemble_model_DWOGF.skops

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:712b614d45498facc9cbd881ea63570f4a5130006877d8f765dbc52d6c787ae8
+size 67038095

ensemble_model_GF.skops

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:22d7e3b82157a0877134653b7f14d5320b8047811283b4ba4a51b9cf332c9e78
+size 40044086

ensemble_model_STROKEHI.skops

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:81f610182edda56a4ace74988212f3ad37888e32860d4531e2b0381914fcb7f2
+size 41369307

ensemble_model_VOCPSHI.skops

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b9d46bb9b61c8034ff400aeae5778e78755310f33eb11a7f3655f29dd7dcd853
+size 46389465

inference (1).py

@@ -0,0 +1,654 @@
+import numpy as np
+import pandas as pd
+import skops.io as sio
+import shap
+import plotly.graph_objects as go
+import os
+import sys
+import warnings
+
+warnings.filterwarnings("ignore", category=UserWarning, module="sklearn")
+
+print("===== Application Startup =====")
+print(f"Working directory: {os.getcwd()}")
+print(f"Files present: {os.listdir('.')}")
+
+# ---------------------------------------------------------------------------
+# Compatibility patch
+# ---------------------------------------------------------------------------
+import sklearn.compose._column_transformer as _ct
+if not hasattr(_ct, "_RemainderColsList"):
+    class _RemainderColsList(list):
+        def __init__(self, lst=None, future_dtype=None):
+            super().__init__(lst or [])
+            self.future_dtype = future_dtype
+    _ct._RemainderColsList = _RemainderColsList
+    import sklearn.compose
+    sklearn.compose._RemainderColsList = _RemainderColsList
+    print("Patched _RemainderColsList into sklearn.compose")
+
+
+# ---------------------------------------------------------------------------
+# Column / feature definitions
+# ---------------------------------------------------------------------------
+
+NUM_COLUMNS = ["AGE", "NACS2YR"]
+CATEG_COLUMNS = [
+    "AGEGPFF", "SEX", "KPS", "DONORF", "GRAFTYPE", "CONDGRPF",
+    "CONDGRP_FINAL", "ATGF", "GVHD_FINAL", "HLA_FINAL",
+    "RCMVPR", "EXCHTFPR", "VOC2YPR", "VOCFRQPR", "SCATXRSN",
+]
+
+FEATURE_NAMES = NUM_COLUMNS + CATEG_COLUMNS
+
+OUTCOMES                = ["DEAD", "GF", "AGVHD", "CGVHD", "VOCPSHI", "STROKEHI", "DWOGF"]
+CLASSIFICATION_OUTCOMES = OUTCOMES
+
+REPORTING_OUTCOMES = [
+    "OS", "EFS", "GF", "DEAD",
+    "AGVHD", "CGVHD", "VOCPSHI", "STROKEHI",
+]
+
+OUTCOME_DESCRIPTIONS = {
+    "OS":       "Overall Survival",
+    "EFS":      "Event-Free Survival",
+    "DEAD":     "Total Mortality",
+    "GF":       "Graft Failure",
+    "AGVHD":    "Acute Graft-versus-Host Disease",
+    "CGVHD":    "Chronic Graft-versus-Host Disease",
+    "VOCPSHI":  "Vaso-Occlusive Crisis Post-HCT",
+    "STROKEHI": "Stroke Post-HCT",
+}
+
+SHAP_OUTCOMES = ["DEAD", "GF", "AGVHD", "CGVHD", "VOCPSHI", "STROKEHI", "OS", "EFS"]
+
+MODEL_DIR           = "."
+CONSENSUS_THRESHOLD = 0.5
+DEFAULT_N_BOOT_CI   = 500
+
+
+# ---------------------------------------------------------------------------
+# Model loading
+# ---------------------------------------------------------------------------
+
+def _load_skops_model(fname):
+    if not os.path.exists(fname):
+        raise RuntimeError(f"Model file not found: {fname}")
+    try:
+        untrusted = sio.get_untrusted_types(file=fname)
+        model = sio.load(fname, trusted=untrusted)
+        print(f"  Loaded: {fname}")
+        return model
+    except Exception as e:
+        raise RuntimeError(f"Failed to load '{fname}': {type(e).__name__}: {e}") from e
+
+
+print("Loading preprocessor...")
+preprocessor = _load_skops_model(os.path.join(MODEL_DIR, "preprocessor.skops"))
+
+print("Loading ensemble models...")
+classification_model_data = {}
+for _o in CLASSIFICATION_OUTCOMES:
+    _path = os.path.join(MODEL_DIR, f"ensemble_model_{_o}.skops")
+    if os.path.exists(_path):
+        classification_model_data[_o] = _load_skops_model(_path)
+    else:
+        print(f"  Warning: Model for {_o} not found at {_path}. Skipping.")
+
+classification_models = {o: d["models"] for o, d in classification_model_data.items()}
+betas                 = {o: d["beta"]   for o, d in classification_model_data.items()}
+priors                = {o: d["prior"]  for o, d in classification_model_data.items()}
+consensus_thresholds  = {
+    o: d.get("consensus_threshold", CONSENSUS_THRESHOLD)
+    for o, d in classification_model_data.items()
+}
+
+calibrators = {}
+for _o, _d in classification_model_data.items():
+    _cal      = None
+    _cal_type = _d.get("calibrator_type", None)
+    if "calibrator" in _d and _d["calibrator"] is not None:
+        if _cal_type is None or _cal_type == "isotonic":
+            _cal = _d["calibrator"]
+        else:
+            print(f"  Warning: outcome '{_o}' has calibrator_type='{_cal_type}'. Skipping.")
+    elif "isotonic_calibrator" in _d and _d["isotonic_calibrator"] is not None:
+        _cal = _d["isotonic_calibrator"]
+    calibrators[_o] = _cal
+
+isotonic_calibrators = calibrators
+
+oof_probs_calibrated = {
+    o: d.get("oof_probs_calibrated") for o, d in classification_model_data.items()
+}
+
+ohe                     = preprocessor.named_transformers_["cat"]
+ohe_feature_names       = ohe.get_feature_names_out(CATEG_COLUMNS)
+processed_feature_names = np.concatenate([NUM_COLUMNS, ohe_feature_names])
+
+print(f"Models loaded: {list(classification_models.keys())}")
+
+
+# ---------------------------------------------------------------------------
+# SHAP background data
+# ---------------------------------------------------------------------------
+
+print("Building SHAP background...")
+np.random.seed(23)
+_n_background = 500
+
+_background_data = {
+    "AGE":           np.random.uniform(5, 50, _n_background),
+    "NACS2YR":       np.random.randint(0, 5, _n_background),
+    "AGEGPFF":       np.random.choice(["<=10", "11-17", "18-29", "30-49", ">=50"], _n_background),
+    "SEX":           np.random.choice(["Male", "Female"], _n_background),
+    "KPS":           np.random.choice(["<90", "≥ 90"], _n_background),
+    "DONORF":        np.random.choice([
+                         "HLA identical sibling", "HLA mismatch relative",
+                         "Matched unrelated donor",
+                         "Mismatched unrelated donor or cord blood",
+                     ], _n_background),
+    "GRAFTYPE":      np.random.choice(["Bone marrow", "Peripheral blood", "Cord blood"], _n_background),
+    "CONDGRPF":      np.random.choice(["MAC", "RIC", "NMA"], _n_background),
+    "CONDGRP_FINAL": np.random.choice(["TBI/Cy", "Bu/Cy", "Flu/Bu", "Flu/Mel"], _n_background),
+    "ATGF":          np.random.choice(["ATG", "Alemtuzumab", "None"], _n_background),
+    "GVHD_FINAL":    np.random.choice(["CNI + MMF", "CNI + MTX", "Post-CY + siro +- MMF"], _n_background),
+    "HLA_FINAL":     np.random.choice(["8/8", "7/8", "≤ 6/8"], _n_background),
+    "RCMVPR":        np.random.choice(["Negative", "Positive"], _n_background),
+    "EXCHTFPR":      np.random.choice(["No", "Yes"], _n_background),
+    "VOC2YPR":       np.random.choice(["No", "Yes"], _n_background),
+    "VOCFRQPR":      np.random.choice(["< 3/yr", "≥ 3/yr"], _n_background),
+    "SCATXRSN":      np.random.choice([
+                         "CNS event", "Acute chest Syndrome",
+                         "Recurrent vaso-occlusive pain", "Recurrent priapism",
+                         "Excessive transfusion requirements/iron overload",
+                         "Cardio-pulmonary", "Chronic transfusion", "Asymptomatic",
+                         "Renal insufficiency", "Splenic sequestration",
+                         "Avascular necrosis", "Hodgkin lymphoma",
+                     ], _n_background),
+}
+
+_background_df  = pd.DataFrame(_background_data)[FEATURE_NAMES]
+_X_background   = preprocessor.transform(_background_df)
+shap_background = shap.maskers.Independent(_X_background)
+print("SHAP background ready.")
+
+
+# ---------------------------------------------------------------------------
+# Calibration helpers
+# ---------------------------------------------------------------------------
+
+def calibrate_probabilities_undersampling(p_s, beta):
+    p_s         = np.asarray(p_s, dtype=float)
+    numerator   = beta * p_s
+    denominator = np.maximum((beta - 1.0) * p_s + 1.0, 1e-10)
+    return np.clip(numerator / denominator, 0.0, 1.0)
+
+
+def predict_consensus_signed_voting(ensemble_models, X_test, threshold=0.5):
+    individual_probas = np.array(
+        [m.predict_proba(X_test)[:, 1] for m in ensemble_models]
+    )
+    binary_preds    = (individual_probas >= threshold).astype(int)
+    signed_votes    = np.where(binary_preds == 1, 1, -1)
+    avg_signed_vote = np.mean(signed_votes, axis=0)
+    consensus_pred  = (avg_signed_vote > 0).astype(int)
+    avg_proba       = np.mean(individual_probas, axis=0)
+    return consensus_pred, avg_proba, avg_signed_vote, individual_probas.flatten()
+
+
+def predict_consensus_majority(ensemble_models, X_test, threshold=0.5):
+    individual_probas = np.array(
+        [m.predict_proba(X_test)[:, 1] for m in ensemble_models]
+    )
+    avg_proba = np.mean(individual_probas, axis=0)
+    return avg_proba, individual_probas.flatten()
+
+
+# ---------------------------------------------------------------------------
+# Bootstrap CI
+# ---------------------------------------------------------------------------
+
+def bootstrap_ci_from_oof(
+    point_estimate: float,
+    oof_probs: np.ndarray,
+    n_boot: int = DEFAULT_N_BOOT_CI,
+    confidence: float = 0.95,
+    random_state: int = 42,
+) -> tuple:
+    if oof_probs is None or len(oof_probs) == 0:
+        return float(point_estimate), float(point_estimate)
+
+    oof_probs  = np.asarray(oof_probs, dtype=float)
+    rng        = np.random.RandomState(random_state)
+    grand_mean = np.mean(oof_probs)
+    n          = len(oof_probs)
+
+    boot_means = np.array([
+        np.mean(rng.choice(oof_probs, size=n, replace=True))
+        for _ in range(n_boot)
+    ])
+
+    shift      = point_estimate - grand_mean
+    boot_means = boot_means + shift
+
+    alpha = 1.0 - confidence
+    lo = float(np.clip(np.percentile(boot_means, 100 * alpha / 2),       0.0, 1.0))
+    hi = float(np.clip(np.percentile(boot_means, 100 * (1 - alpha / 2)), 0.0, 1.0))
+    return lo, hi
+
+
+# ---------------------------------------------------------------------------
+# Calibration dispatch
+# ---------------------------------------------------------------------------
+
+def _calibrate_point(outcome: str, raw_prob: float, use_calibration: bool) -> float:
+    beta   = betas[outcome]
+    p_beta = float(calibrate_probabilities_undersampling([raw_prob], beta)[0])
+    if not use_calibration:
+        return p_beta
+    cal = calibrators.get(outcome)
+    if cal is None:
+        return p_beta
+    return float(cal.transform([p_beta])[0])
+
+
+# ---------------------------------------------------------------------------
+# Main prediction functions
+# ---------------------------------------------------------------------------
+
+def predict_all_outcomes(
+    user_inputs,
+    use_calibration: bool = True,
+    use_signed_voting: bool = True,
+    n_boot_ci: int = DEFAULT_N_BOOT_CI,
+):
+    if isinstance(user_inputs, dict):
+        input_df = pd.DataFrame([user_inputs])
+    else:
+        input_df = pd.DataFrame([user_inputs], columns=FEATURE_NAMES)
+
+    input_df = input_df[FEATURE_NAMES]
+    X        = preprocessor.transform(input_df)
+
+    probs, intervals = {}, {}
+
+    for o in CLASSIFICATION_OUTCOMES:
+        if o not in classification_models:
+            continue
+
+        threshold = consensus_thresholds.get(o, CONSENSUS_THRESHOLD)
+
+        if use_signed_voting:
+            _, uncalib_arr, _, _ = predict_consensus_signed_voting(
+                classification_models[o], X, threshold
+            )
+        else:
+            uncalib_arr, _ = predict_consensus_majority(
+                classification_models[o], X, threshold
+            )
+
+        raw_prob   = float(uncalib_arr[0])
+        event_prob = _calibrate_point(o, raw_prob, use_calibration)
+
+        lo, hi = bootstrap_ci_from_oof(
+            point_estimate=event_prob,
+            oof_probs=oof_probs_calibrated.get(o),
+            n_boot=n_boot_ci,
+        )
+
+        probs[o]     = event_prob
+        intervals[o] = (lo, hi)
+
+    # OS = 1 - P(DEAD)
+    if "DEAD" in probs:
+        p_dead      = probs["DEAD"]
+        probs["OS"] = float(1.0 - p_dead)
+        dead_lo, dead_hi = intervals["DEAD"]
+        intervals["OS"]  = (
+            float(np.clip(1.0 - dead_hi, 0, 1)),
+            float(np.clip(1.0 - dead_lo, 0, 1)),
+        )
+
+    # EFS = 1 - P(DWOGF) - P(GF)
+    if "DWOGF" in probs and "GF" in probs:
+        p_dwogf      = probs["DWOGF"]
+        p_gf         = probs["GF"]
+        probs["EFS"] = float(np.clip(1.0 - p_dwogf - p_gf, 0.0, 1.0))
+
+        oof_dwogf = oof_probs_calibrated.get("DWOGF")
+        oof_gf    = oof_probs_calibrated.get("GF")
+
+        if oof_dwogf is not None and oof_gf is not None:
+            oof_dwogf = np.asarray(oof_dwogf, dtype=float)
+            oof_gf    = np.asarray(oof_gf,    dtype=float)
+            n_min     = min(len(oof_dwogf), len(oof_gf))
+            oof_dwogf = oof_dwogf[:n_min]
+            oof_gf    = oof_gf[:n_min]
+
+            rng         = np.random.RandomState(42)
+            grand_dwogf = np.mean(oof_dwogf)
+            grand_gf    = np.mean(oof_gf)
+            shift_dwogf = p_dwogf - grand_dwogf
+            shift_gf    = p_gf    - grand_gf
+
+            efs_boot = np.array([
+                np.clip(
+                    1.0
+                    - (np.mean(rng.choice(oof_dwogf, size=n_min, replace=True)) + shift_dwogf)
+                    - (np.mean(rng.choice(oof_gf,    size=n_min, replace=True)) + shift_gf),
+                    0.0, 1.0,
+                )
+                for _ in range(n_boot_ci)
+            ])
+            intervals["EFS"] = (
+                float(np.percentile(efs_boot, 2.5)),
+                float(np.percentile(efs_boot, 97.5)),
+            )
+        else:
+            intervals["EFS"] = (probs["EFS"], probs["EFS"])
+
+    return probs, intervals
+
+
+def predict_with_comparison(user_inputs, n_boot_ci: int = DEFAULT_N_BOOT_CI):
+    cal_probs,   cal_intervals   = predict_all_outcomes(user_inputs, True,  True, n_boot_ci)
+    uncal_probs, uncal_intervals = predict_all_outcomes(user_inputs, False, True, n_boot_ci)
+    return (cal_probs, cal_intervals), (uncal_probs, uncal_intervals)
+
+
+# ---------------------------------------------------------------------------
+# SHAP helpers
+# ---------------------------------------------------------------------------
+
+def _get_shap_values_for_model_outcome(user_inputs, model_outcome, invert, X_proc):
+    all_model_shap_vals = []
+    for rf_model in classification_models[model_outcome]:
+        explainer = shap.TreeExplainer(rf_model, model_output="probability", data=shap_background)
+        shap_vals = explainer.shap_values(X_proc)
+        if isinstance(shap_vals, list):
+            shap_vals = shap_vals[1]
+        elif shap_vals.ndim == 3 and shap_vals.shape[2] == 2:
+            shap_vals = shap_vals[:, :, 1]
+        sv = shap_vals[0]
+        if invert:
+            sv = -sv
+        all_model_shap_vals.append(sv)
+    return np.array(all_model_shap_vals)
+
+
+def compute_shap_values_with_direction(user_inputs, outcome, max_display=10):
+    if isinstance(user_inputs, dict):
+        input_df = pd.DataFrame([user_inputs])
+    else:
+        input_df = pd.DataFrame([user_inputs], columns=FEATURE_NAMES)
+
+    X_proc = preprocessor.transform(input_df)
+
+    processed_to_orig = {f: f for f in NUM_COLUMNS}
+    for pf in ohe_feature_names:
+        processed_to_orig[pf] = pf.split("_", 1)[0]
+
+    if outcome == "OS":
+        raw_shap = _get_shap_values_for_model_outcome(user_inputs, "DEAD", invert=True, X_proc=X_proc)
+    elif outcome == "EFS":
+        shap_dwogf = _get_shap_values_for_model_outcome(user_inputs, "DWOGF", invert=True, X_proc=X_proc)
+        shap_gf    = _get_shap_values_for_model_outcome(user_inputs, "GF",    invert=True, X_proc=X_proc)
+        raw_shap   = np.concatenate([shap_dwogf, shap_gf], axis=0)
+    else:
+        raw_shap = _get_shap_values_for_model_outcome(user_inputs, outcome, invert=False, X_proc=X_proc)
+
+    unique_orig_features = list(dict.fromkeys(processed_to_orig.values()))
+    n_models             = len(raw_shap)
+
+    model_shap_by_orig = np.zeros((n_models, len(unique_orig_features)))
+    for model_idx in range(n_models):
+        agg_by_orig = {}
+        for i, pf in enumerate(processed_feature_names):
+            orig = processed_to_orig[pf]
+            agg_by_orig.setdefault(orig, 0.0)
+            agg_by_orig[orig] += raw_shap[model_idx, i]
+        for feat_idx, feat_name in enumerate(unique_orig_features):
+            model_shap_by_orig[model_idx, feat_idx] = agg_by_orig.get(feat_name, 0.0)
+
+    mean_shap_vals = np.mean(model_shap_by_orig, axis=0)
+
+    rng                  = np.random.RandomState(42)
+    bootstrap_shap_means = np.array([
+        np.mean(model_shap_by_orig[rng.choice(n_models, size=n_models, replace=True)], axis=0)
+        for _ in range(DEFAULT_N_BOOT_CI)
+    ])
+    shap_ci_low  = np.percentile(bootstrap_shap_means, 2.5,  axis=0)
+    shap_ci_high = np.percentile(bootstrap_shap_means, 97.5, axis=0)
+
+    order = np.argsort(-np.abs(mean_shap_vals))
+
+    top_feat_names = []
+    for i in order[:max_display]:
+        feat_name = unique_orig_features[i]
+        if feat_name in user_inputs:
+            val = user_inputs[feat_name]
+            if isinstance(val, float) and val != int(val):
+                display_name = f"{feat_name} = {val:.2f}"
+            elif isinstance(val, (int, float)):
+                display_name = f"{feat_name} = {int(val)}"
+            else:
+                val_str = str(val)
+                if len(val_str) > 20:
+                    val_str = val_str[:17] + "..."
+                display_name = f"{feat_name} = {val_str}"
+        else:
+            display_name = feat_name
+        top_feat_names.append(display_name)
+
+    top_feat_names = top_feat_names[::-1]
+    top_shap_vals  = mean_shap_vals[order][:max_display][::-1]
+    top_ci_low     = shap_ci_low[order][:max_display][::-1]
+    top_ci_high    = shap_ci_high[order][:max_display][::-1]
+
+    return top_feat_names, top_shap_vals, top_ci_low, top_ci_high
+
+
+def create_shap_plot(user_inputs, outcome, max_display=10):
+    feat_names, shap_vals, ci_low, ci_high = compute_shap_values_with_direction(
+        user_inputs, outcome, max_display
+    )
+
+    colors      = ["blue" if v >= 0 else "red" for v in shap_vals]
+    error_minus = shap_vals - ci_low
+    error_plus  = ci_high - shap_vals
+
+    fig = go.Figure()
+    fig.add_trace(go.Bar(
+        y=feat_names,
+        x=shap_vals,
+        orientation="h",
+        marker=dict(color=colors),
+        showlegend=False,
+        error_x=dict(
+            type="data",
+            symmetric=False,
+            array=error_plus,
+            arrayminus=error_minus,
+            color="gray",
+            thickness=1.5,
+            width=4,
+        ),
+    ))
+    fig.add_vline(x=0, line_width=1, line_color="black")
+
+    fig.update_layout(
+        title=dict(
+            text=OUTCOME_DESCRIPTIONS.get(outcome, outcome),
+            x=0.5, xanchor="center",
+            font=dict(size=14, color="black"),
+        ),
+        xaxis_title="SHAP value",
+        yaxis_title="",
+        height=400,
+        margin=dict(l=120, r=60, t=50, b=50),
+        plot_bgcolor="white",
+        paper_bgcolor="white",
+        xaxis=dict(showgrid=True, gridcolor="lightgray", zeroline=True,
+                   zerolinecolor="black", zerolinewidth=1),
+        yaxis=dict(showgrid=False),
+    )
+    return fig
+
+
+def create_all_shap_plots(user_inputs, max_display=10):
+    return {o: create_shap_plot(user_inputs, o, max_display) for o in SHAP_OUTCOMES}
+
+
+# ---------------------------------------------------------------------------
+# Icon array
+# ---------------------------------------------------------------------------
+# Root cause of previous gaps / distortion:
+#   Plotly shape coords are in DATA units. If px-per-data-unit differs on
+#   x vs y axes the circle head becomes an ellipse and spacing looks uneven.
+#
+# Fix:
+#   • Use EQUAL axis spans on x and y  (both = cols + 2*pad = 10.3)
+#   • Set width and height so that usable pixels are EQUAL on both axes:
+#       usable_w = W - margin_l - margin_r  = W - 20
+#       usable_h = H - margin_t - margin_b  = H - 100
+#       usable_w == usable_h  →  H = W + 80
+#   • This guarantees 1 data-unit = same number of pixels on both axes,
+#     so circles are round and spacing is perfectly uniform.
+# ---------------------------------------------------------------------------
+
+def _stick_figure(cx, cy, color, s):
+    """
+    Returns Plotly shape dicts for a stick figure centred at (cx, cy).
+    s  = scale (data units).  With a cell size of 1.0, s ≈ 0.46 gives
+    a figure that fills ~75 % of the cell vertically.
+
+    Anatomy (all offsets relative to cy):
+      head centre  :  cy + s*0.55          radius s*0.18
+      neck top     :  cy + s*0.35
+      hip          :  cy - s*0.15
+      arm branch   :  cy + s*0.18
+      foot         :  cy - s*0.55
+    """
+    shapes = []
+    lw = dict(color=color, width=1.8)   # fixed pixel width — looks consistent
+
+    # head
+    hr = s * 0.18
+    hy = cy + s * 0.55
+    shapes.append(dict(
+        type="circle", xref="x", yref="y",
+        x0=cx - hr, y0=hy - hr,
+        x1=cx + hr, y1=hy + hr,
+        fillcolor=color,
+        line=dict(color=color, width=0),
+    ))
+
+    neck_y = cy + s * 0.35
+    hip_y  = cy - s * 0.15
+    arm_y  = cy + s * 0.18
+    foot_y = cy - s * 0.55
+
+    # spine
+    shapes.append(dict(type="line", xref="x", yref="y",
+        x0=cx, y0=neck_y, x1=cx, y1=hip_y, line=lw))
+
+    # arms
+    adx = s * 0.32
+    ady = s * 0.15
+    shapes.append(dict(type="line", xref="x", yref="y",
+        x0=cx, y0=arm_y, x1=cx - adx, y1=arm_y - ady, line=lw))
+    shapes.append(dict(type="line", xref="x", yref="y",
+        x0=cx, y0=arm_y, x1=cx + adx, y1=arm_y - ady, line=lw))
+
+    # legs
+    ldx = s * 0.26
+    shapes.append(dict(type="line", xref="x", yref="y",
+        x0=cx, y0=hip_y, x1=cx - ldx, y1=foot_y, line=lw))
+    shapes.append(dict(type="line", xref="x", yref="y",
+        x0=cx, y0=hip_y, x1=cx + ldx, y1=foot_y, line=lw))
+
+    return shapes
+
+
+def icon_array(probability, outcome):
+    outcome_labels = {
+        "DEAD":     ("Death",           "Overall Survival"),
+        "GF":       ("Graft Failure",   "No Graft Failure"),
+        "AGVHD":    ("AGVHD",           "No AGVHD"),
+        "CGVHD":    ("CGVHD",           "No CGVHD"),
+        "VOCPSHI":  ("VOC Post-HCT",    "No VOC Post-HCT"),
+        "STROKEHI": ("Stroke Post-HCT", "No Stroke Post-HCT"),
+    }
+
+    event_label, no_event_label = outcome_labels.get(outcome, ("Event", "No Event"))
+    n_event    = round(probability * 100)
+    n_no_event = 100 - n_event
+    cols, rows = 10, 10
+
+    # ── Layout constants ──────────────────────────────────────────────────
+    # Icons sit on an integer grid 0..9 × 0..9.
+    # Padding of 0.65 on each side → axis span = 9 + 2*0.65 = 10.30
+    # Margins: left=10, right=10, top=95, bottom=10
+    # usable_w = W - 20 ;  usable_h = H - 105
+    # To ensure px_per_unit identical on both axes: usable_w == usable_h
+    #   → H = W + 85
+    # We also enforce equal axis spans (both 10.30).
+
+    PAD  = 0.65
+    W    = 400
+    H    = W + 85          # = 485  →  usable = 380 px on both axes
+    S    = 0.46            # figure scale (≈ 75 % vertical fill per cell)
+
+    x_lo, x_hi = -PAD, (cols - 1) + PAD   # -0.65 … 9.65  span=10.30
+    y_lo, y_hi = -PAD, (rows - 1) + PAD   # -0.65 … 9.65  span=10.30
+
+    all_shapes = []
+    icon_idx   = 0
+
+    for row in range(rows):       # row 0 → top of grid
+        for col in range(cols):   # col 0 → left
+            color = "#e05555" if icon_idx < n_event else "#3bbfad"
+            cx    = col
+            cy    = (rows - 1) - row    # invert: row 0 → cy=9 (top)
+            all_shapes.extend(_stick_figure(cx, cy, color, S))
+            icon_idx += 1
+
+    fig = go.Figure()
+    fig.update_layout(
+        title=dict(
+            text=(
+                f"<b>{OUTCOME_DESCRIPTIONS.get(outcome, outcome)}</b><br>"
+                f"<span style='font-size:12px;color:#e05555'>"
+                f"■ {event_label}: {n_event}%</span>"
+                f"&nbsp;&nbsp;"
+                f"<span style='font-size:12px;color:#3bbfad'>"
+                f"■ {no_event_label}: {n_no_event}%</span>"
+            ),
+            x=0.5, xanchor="center",
+            font=dict(size=14, color="black"),
+        ),
+        shapes=all_shapes,
+        xaxis=dict(
+            range=[x_lo, x_hi],
+            showgrid=False, zeroline=False, showticklabels=False,
+            fixedrange=True,
+        ),
+        yaxis=dict(
+            range=[y_lo, y_hi],
+            showgrid=False, zeroline=False, showticklabels=False,
+            fixedrange=True,
+            # scaleanchor / scaleratio intentionally OMITTED —
+            # equal spans + equal usable pixels already guarantee
+            # identical px/unit on both axes without distortion.
+        ),
+        width=W,
+        height=H,
+        margin=dict(l=10, r=10, t=95, b=10),
+        plot_bgcolor="white",
+        paper_bgcolor="white",
+    )
+    return fig
+
+
+print("===== inference.py loaded successfully =====")

preprocessor.skops

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dda5bfd9eeac05a1c29b9c28d3dd10911e651002a7273e96848cd33fe0706b94
+size 123373

requirements (3).txt

@@ -0,0 +1,9 @@
+gradio
+pandas
+numpy
+scikit-learn==1.8.0
+shap
+matplotlib
+plotly
+skops
+openpyxl