Create app.py

app.py

@@ -0,0 +1,401 @@
+import math
+from dataclasses import dataclass, asdict
+import gradio as gr
+
+"""
+FFR-CT AI ROI Calculator
+- Built for Hugging Face Spaces (Gradio)
+- Focus: Clinical, Financial, and Operational ROI
+
+Assumptions & Notes
+- "With AI" refers to adopting FFR-CT + (optionally) AI-QPA billing.
+- "Without AI" baseline assumes a CCTA-first pathway without FFR-CT.
+- Savings from reduced unnecessary diagnostic ICA leverage the provided 69% reduction figure,
+  scaled by adoption (uptake).
+- Additional testing costs are approximated via stress-test costs when one-test diagnosis fails.
+- Downstream revascularization (PCI/CABG) revenue is optional (off by default), given it depends on site type.
+- Ops value accounts for 2 parts: (a) faster decision-making (bed-hours value) and (b) clinician touch-time reduction.
+
+You can tune any assumptions in the Advanced section.
+"""
+
+@dataclass
+class Defaults:
+    # Volumes
+    monthly_eligible_ccta: int = 100  # Monthly eligible CCTA patients
+    uptake_pct: float = 60.0  # % of eligible getting FFR-CT (policy/site dependent)
+
+    # Reimbursement (USD)
+    reimb_ffrct: float = 1017.0
+    reimb_ai_qpa: float = 950.0
+    pct_billed_ai_qpa: float = 60.0  # % of FFR-CT also billed with AI-QPA
+
+    # Core performance
+    one_test_dx_pct: float = 97.0  # with FFR-CT (i.e., 3% need add'l testing)
+    dec_unnec_ica_pct: float = 69.0  # reduction in unnecessary diagnostic ICAs
+    more_likely_revasc_pct: float = 78.0  # relative lift in identifying revasc candidates
+    revasc_prevalence_pct: float = 10.0  # true prevalence among eligible
+
+    # Costs (USD)
+    vendor_per_case_cost: float = 350.0
+    platform_monthly_cost: float = 1000.0  # = $12k/yr
+    stress_test_cost: float = 400.0
+    net_cost_per_diag_ica: float = 5000.0  # allow negative if ICA is profit-positive
+
+    # Ops economics (USD)
+    bed_hour_value: float = 100.0
+    clinician_hour_cost: float = 150.0
+
+    # Time effects
+    ai_time_to_decision_min: float = 90.0  # faster time from CCTA -> decision (minutes)
+    clinician_touch_reduction_pct: float = 30.0
+    baseline_clinician_touch_min: float = 30.0
+
+    # Baseline (without AI) assumptions
+    baseline_diag_ica_rate_pct: float = 30.0  # % of eligible that go to diagnostic ICA
+    baseline_additional_testing_rate_pct: float = 30.0  # % needing add'l testing without FFR-CT
+
+    # Optional downstream value
+    include_revasc_value: bool = False
+    value_per_revasc: float = 0.0  # Only used if include_revasc_value is True
+
+DEFAULTS = Defaults()
+
+
+def _pct(x):
+    return max(0.0, min(100.0, float(x)))
+
+
+def _pos(x):
+    return max(0.0, float(x))
+
+
+def compute_roi(
+    monthly_eligible_ccta,
+    uptake_pct,
+    reimb_ffrct,
+    reimb_ai_qpa,
+    pct_billed_ai_qpa,
+    one_test_dx_pct,
+    dec_unnec_ica_pct,
+    more_likely_revasc_pct,
+    revasc_prevalence_pct,
+    vendor_per_case_cost,
+    platform_monthly_cost,
+    stress_test_cost,
+    net_cost_per_diag_ica,
+    bed_hour_value,
+    clinician_hour_cost,
+    ai_time_to_decision_min,
+    clinician_touch_reduction_pct,
+    baseline_clinician_touch_min,
+    baseline_diag_ica_rate_pct,
+    baseline_additional_testing_rate_pct,
+    include_revasc_value,
+    value_per_revasc,
+):
+    # Sanitize
+    monthly_eligible_ccta = _pos(monthly_eligible_ccta)
+    uptake = _pct(uptake_pct) / 100.0
+    reimb_ffrct = float(reimb_ffrct)
+    reimb_ai_qpa = float(reimb_ai_qpa)
+    pct_billed_ai_qpa = _pct(pct_billed_ai_qpa) / 100.0
+    one_test_dx = _pct(one_test_dx_pct) / 100.0
+    need_addl_with_ai = 1.0 - one_test_dx
+    dec_unnec_ica = _pct(dec_unnec_ica_pct) / 100.0
+    more_likely_revasc = _pct(more_likely_revasc_pct) / 100.0
+    revasc_prev = _pct(revasc_prevalence_pct) / 100.0
+
+    vendor_per_case_cost = float(vendor_per_case_cost)
+    platform_monthly_cost = float(platform_monthly_cost)
+    stress_test_cost = float(stress_test_cost)
+    net_cost_per_diag_ica = float(net_cost_per_diag_ica)
+
+    bed_hour_value = float(bed_hour_value)
+    clinician_hour_cost = float(clinician_hour_cost)
+    ai_time_to_decision_min = _pos(ai_time_to_decision_min)
+    clinician_touch_reduction_pct = _pct(clinician_touch_reduction_pct) / 100.0
+    baseline_clinician_touch_min = _pos(baseline_clinician_touch_min)
+
+    baseline_diag_ica_rate = _pct(baseline_diag_ica_rate_pct) / 100.0
+    baseline_additional_testing_rate = _pct(baseline_additional_testing_rate_pct) / 100.0
+
+    include_revasc_value = bool(include_revasc_value)
+    value_per_revasc = float(value_per_revasc)
+
+    # Volumes
+    annual_eligible = monthly_eligible_ccta * 12.0
+    annual_uptake_cases = annual_eligible * uptake
+
+    # Baseline (without AI)
+    baseline_additional_tests = annual_eligible * baseline_additional_testing_rate
+    baseline_additional_tests_cost = baseline_additional_tests * stress_test_cost
+
+    baseline_diag_ica_total = annual_eligible * baseline_diag_ica_rate
+    baseline_revasc_true = annual_eligible * revasc_prev
+    baseline_unnecessary_ica = max(0.0, baseline_diag_ica_total - baseline_revasc_true)
+    baseline_unnecessary_ica_cost = baseline_unnecessary_ica * net_cost_per_diag_ica
+
+    baseline_revenue = 0.0  # no FFR-CT/AI-QPA billing without AI
+    baseline_costs = baseline_additional_tests_cost + baseline_unnecessary_ica_cost
+    baseline_ops_value = 0.0
+    baseline_net = baseline_revenue - baseline_costs + baseline_ops_value
+
+    # With AI
+    with_ai_revenue = (
+        annual_uptake_cases * reimb_ffrct
+        + annual_uptake_cases * pct_billed_ai_qpa * reimb_ai_qpa
+    )
+
+    with_ai_vendor_costs = annual_uptake_cases * vendor_per_case_cost
+    with_ai_platform_costs = platform_monthly_cost * 12.0
+
+    with_ai_additional_tests = annual_uptake_cases * need_addl_with_ai
+    with_ai_additional_tests_cost = with_ai_additional_tests * stress_test_cost
+
+    # Unnecessary ICA reduction scaled by uptake
+    avoided_unnec_ica = baseline_unnecessary_ica * dec_unnec_ica * uptake
+    with_ai_unnecessary_ica = max(0.0, baseline_unnecessary_ica - avoided_unnec_ica)
+    with_ai_unnecessary_ica_cost = with_ai_unnecessary_ica * net_cost_per_diag_ica
+
+    # Downstream revasc capture (optional; conservative default = off)
+    extra_revasc_identified = annual_eligible * revasc_prev * more_likely_revasc * uptake
+    revasc_value = extra_revasc_identified * value_per_revasc if include_revasc_value else 0.0
+
+    # Ops value
+    time_value = (annual_uptake_cases * (ai_time_to_decision_min / 60.0) * bed_hour_value)
+    clinician_time_saved_hours = annual_uptake_cases * (baseline_clinician_touch_min / 60.0) * clinician_touch_reduction_pct
+    clinician_time_value = clinician_time_saved_hours * clinician_hour_cost
+
+    with_ai_ops_value = time_value + clinician_time_value
+
+    with_ai_costs = with_ai_vendor_costs + with_ai_platform_costs + with_ai_additional_tests_cost + with_ai_unnecessary_ica_cost
+    with_ai_net = with_ai_revenue - with_ai_costs + with_ai_ops_value + revasc_value
+
+    # Incremental view (AI program impact)
+    incr_revenue = with_ai_revenue - baseline_revenue
+    incr_costs = with_ai_costs - baseline_costs
+    incr_ops_value = with_ai_ops_value - baseline_ops_value
+    incr_revasc_value = revasc_value
+
+    net_impact = incr_revenue - incr_costs + incr_ops_value + incr_revasc_value
+
+    ai_program_costs = with_ai_vendor_costs + with_ai_platform_costs  # denominator for ROI
+    roi_pct = (net_impact / ai_program_costs * 100.0) if ai_program_costs > 0 else 0.0
+
+    # Payback
+    per_case_net_impact = (net_impact / annual_uptake_cases) if annual_uptake_cases > 0 else 0.0
+    cases_to_payback = (ai_program_costs / per_case_net_impact) if per_case_net_impact > 0 else math.inf
+    months_to_payback = (cases_to_payback / (monthly_eligible_ccta * uptake)) if (monthly_eligible_ccta * uptake) > 0 and cases_to_payback != math.inf else math.inf
+
+    # Build summaries
+    with_ai_summary = {
+        "Annual revenue (FFR-CT + AI-QPA)": with_ai_revenue,
+        "Program costs (vendor + platform)": with_ai_vendor_costs + with_ai_platform_costs,
+        "Add'l testing cost": with_ai_additional_tests_cost,
+        "Unnecessary ICA cost": with_ai_unnecessary_ica_cost,
+        "Ops value (time + clinician)": with_ai_ops_value,
+        "Downstream revasc value": revasc_value,
+        "Net (with AI)": with_ai_net,
+    }
+
+    without_ai_summary = {
+        "Annual revenue": baseline_revenue,
+        "Add'l testing cost": baseline_additional_tests_cost,
+        "Unnecessary ICA cost": baseline_unnecessary_ica_cost,
+        "Ops value": baseline_ops_value,
+        "Net (without AI)": baseline_net,
+    }
+
+    overall = {
+        "Incremental revenue": incr_revenue,
+        "Incremental costs (incl. tests/ICA)": incr_costs,
+        "Incremental ops value": incr_ops_value,
+        "Downstream revasc value": incr_revasc_value,
+        "Net impact": net_impact,
+        "ROI % (on AI program costs)": roi_pct,
+        "Cases to payback": cases_to_payback,
+        "Months to payback": months_to_payback,
+    }
+
+    # Pretty text blocks
+    def money(x):
+        if x == math.inf:
+            return "∞"
+        return f"${x:,.0f}"
+
+    def num(x):
+        if x == math.inf:
+            return "∞"
+        return f"{x:,.1f}"
+
+    with_ai_md = f"""
+### With AI
+- **Annual revenue (FFR-CT + AI-QPA):** {money(with_ai_revenue)}
+- **Program costs (vendor + platform):** {money(with_ai_vendor_costs + with_ai_platform_costs)}
+- **Add'l testing cost:** {money(with_ai_additional_tests_cost)}
+- **Unnecessary ICA cost:** {money(with_ai_unnecessary_ica_cost)}
+- **Ops value (time + clinician):** {money(with_ai_ops_value)}
+- **Downstream revasc value:** {money(revasc_value)}
+- **Net (with AI):** **{money(with_ai_net)}**
+"""
+
+    without_ai_md = f"""
+### Without AI
+- **Annual revenue:** {money(baseline_revenue)}
+- **Add'l testing cost:** {money(baseline_additional_tests_cost)}
+- **Unnecessary ICA cost:** {money(baseline_unnecessary_ica_cost)}
+- **Ops value:** {money(baseline_ops_value)}
+- **Net (without AI):** **{money(baseline_net)}**
+"""
+
+    overall_md = f"""
+### Overall Impact
+- **Incremental revenue:** {money(incr_revenue)}
+- **Incremental costs (incl. tests/ICA):** {money(incr_costs)}
+- **Incremental ops value:** {money(incr_ops_value)}
+- **Downstream revasc value:** {money(incr_revasc_value)}
+- **Net impact:** **{money(net_impact)}**
+- **ROI % (on AI program costs):** **{roi_pct:,.1f}%**
+- **Cases to payback:** {num(cases_to_payback)}
+- **Months to payback:** {num(months_to_payback)}
+"""
+
+    return with_ai_md, without_ai_md, overall_md
+
+
+def build_ui():
+    with gr.Blocks(theme=gr.themes.Soft(), css="""
+    .card {border: 1px solid #e5e7eb; border-radius: 16px; padding: 16px; box-shadow: 0 1px 2px rgba(0,0,0,0.05);}
+    .title {font-weight: 700; font-size: 1.1rem;}
+    .muted {color: #6b7280;}
+    """) as demo:
+        gr.Markdown("""
+# FFR‑CT AI ROI Calculator
+**For providers, imaging centers, and AMCs.**
+Use your site's numbers or try the defaults. Results show **With AI**, **Without AI**, and **Overall** impact across **clinical, financial, and operational** dimensions.
+""")
+
+        with gr.Row():
+            with gr.Column():
+                monthly_eligible_ccta = gr.Slider(
+                    label="Monthly eligible CCTA volume",
+                    minimum=0,
+                    maximum=2000,
+                    step=10,
+                    value=DEFAULTS.monthly_eligible_ccta,
+                    info="Approx. number of CCTA patients per month who would be eligible for FFR‑CT"
+                )
+                uptake_pct = gr.Slider(
+                    label="Uptake (eligible getting FFR‑CT, %)",
+                    minimum=0,
+                    maximum=100,
+                    step=1,
+                    value=DEFAULTS.uptake_pct,
+                    info="Share of eligible patients who actually get FFR‑CT"
+                )
+                with gr.Accordion("Reimbursement & Costs", open=True):
+                    reimb_ffrct = gr.Number(label="Reimbursement: FFR‑CT ($)", value=DEFAULTS.reimb_ffrct, info="CMS 2025")
+                    reimb_ai_qpa = gr.Number(label="Reimbursement: AI‑QPA ($)", value=DEFAULTS.reimb_ai_qpa, info="CMS 2025")
+                    pct_billed_ai_qpa = gr.Slider(label="% billed AI‑QPA",
+                                                  minimum=0, maximum=100, step=5, value=DEFAULTS.pct_billed_ai_qpa,
+                                                  info="Share of FFR‑CT cases where AI‑QPA is billed")
+                    vendor_per_case_cost = gr.Number(label="Vendor per‑case cost ($)", value=DEFAULTS.vendor_per_case_cost)
+                    platform_monthly_cost = gr.Number(label="Platform cost / month ($)", value=DEFAULTS.platform_monthly_cost)
+                    stress_test_cost = gr.Number(label="Stress test cost ($)", value=DEFAULTS.stress_test_cost)
+                    net_cost_per_diag_ica = gr.Number(label="Net cost per diagnostic ICA ($)", value=DEFAULTS.net_cost_per_diag_ica,
+                                                      info="Allow negative if ICA is net profit‑positive at your site")
+
+                with gr.Accordion("Clinical Performance & Ops (Advanced)", open=False):
+                    one_test_dx_pct = gr.Slider(label="One‑test diagnosis with FFR‑CT (%)",
+                                                minimum=80, maximum=100, step=1, value=DEFAULTS.one_test_dx_pct,
+                                                info="Percent of cases resolved with CCTA+FFR‑CT, no extra tests")
+                    dec_unnec_ica_pct = gr.Slider(label="Decrease in unnecessary diagnostic ICAs (%)",
+                                                   minimum=0, maximum=100, step=1, value=DEFAULTS.dec_unnec_ica_pct,
+                                                   info="Relative reduction vs baseline, scaled by uptake")
+                    more_likely_revasc_pct = gr.Slider(label="More likely to identify revasc candidates (%)",
+                                                        minimum=0, maximum=200, step=1, value=DEFAULTS.more_likely_revasc_pct,
+                                                        info="Relative lift, used only if downstream value is enabled")
+                    revasc_prevalence_pct = gr.Slider(label="True revasc prevalence among eligible (%)",
+                                                       minimum=0, maximum=100, step=1, value=DEFAULTS.revasc_prevalence_pct)
+
+                    bed_hour_value = gr.Number(label="Bed‑hour value ($/hour)", value=DEFAULTS.bed_hour_value)
+                    clinician_hour_cost = gr.Number(label="Clinician hour cost ($/hour)", value=DEFAULTS.clinician_hour_cost)
+                    ai_time_to_decision_min = gr.Number(label="AI time CCTA → decision saved (min)", value=DEFAULTS.ai_time_to_decision_min)
+                    clinician_touch_reduction_pct = gr.Slider(label="Clinician touch‑time reduction with AI (%)",
+                                                               minimum=0, maximum=100, step=5, value=DEFAULTS.clinician_touch_reduction_pct)
+                    baseline_clinician_touch_min = gr.Number(label="Baseline clinician touch‑time per case (min)",
+                                                             value=DEFAULTS.baseline_clinician_touch_min)
+
+                    baseline_diag_ica_rate_pct = gr.Slider(label="Baseline diagnostic ICA rate (%)",
+                                                            minimum=0, maximum=100, step=1, value=DEFAULTS.baseline_diag_ica_rate_pct,
+                                                            info="Share of eligible patients who go to diagnostic ICA without AI")
+                    baseline_additional_testing_rate_pct = gr.Slider(label="Baseline additional testing rate (%)",
+                                                                       minimum=0, maximum=100, step=1, value=DEFAULTS.baseline_additional_testing_rate_pct,
+                                                                       info="Share needing extra tests without AI")
+
+                    include_revasc_value = gr.Checkbox(label="Include downstream revascularization value", value=DEFAULTS.include_revasc_value)
+                    value_per_revasc = gr.Number(label="Value per revascularization captured ($)", value=DEFAULTS.value_per_revasc,
+                                                  info="Set only if your site captures revasc value; else leave 0")
+
+            with gr.Column():
+                with gr.Row():
+                    with_ai_card = gr.Markdown(elem_classes=["card"])    # With AI
+                    without_ai_card = gr.Markdown(elem_classes=["card"]) # Without AI
+                overall_card = gr.Markdown(elem_classes=["card"])         # Overall impact
+
+        inputs = [
+            monthly_eligible_ccta,
+            uptake_pct,
+            reimb_ffrct,
+            reimb_ai_qpa,
+            pct_billed_ai_qpa,
+            one_test_dx_pct,
+            dec_unnec_ica_pct,
+            more_likely_revasc_pct,
+            revasc_prevalence_pct,
+            vendor_per_case_cost,
+            platform_monthly_cost,
+            stress_test_cost,
+            net_cost_per_diag_ica,
+            bed_hour_value,
+            clinician_hour_cost,
+            ai_time_to_decision_min,
+            clinician_touch_reduction_pct,
+            baseline_clinician_touch_min,
+            baseline_diag_ica_rate_pct,
+            baseline_additional_testing_rate_pct,
+            include_revasc_value,
+            value_per_revasc,
+        ]
+
+        def _update(*args):
+            return compute_roi(*args)
+
+        # Initial compute & reactive updates
+        for comp in inputs:
+            comp.change(_update, inputs=inputs, outputs=[with_ai_card, without_ai_card, overall_card])
+
+        # Run once on load with defaults
+        demo.load(_update, inputs=inputs, outputs=[with_ai_card, without_ai_card, overall_card])
+
+        gr.Markdown(
+            """
+---
+**How to use this app**
+- Start with your **monthly eligible** volume and **uptake**.
+- Check or edit **reimbursement** and **costs** if your site differs.
+- Optionally expand **Advanced** to fine-tune baseline and ops assumptions.
+- The cards update live with **With AI**, **Without AI**, and **Overall** impact, including **ROI** and **payback**.
+            """
+        )
+
+    return demo
+
+
+def main():
+    demo = build_ui()
+    demo.queue().launch()
+
+if __name__ == "__main__":
+    main()