Cardiovascular Risk Visualization & Prediction

• 

  This is the user interface dynamically changes when data is updated

1. Problem Statemen: The Clinical Bottleneck in Coronary Artery Disease (CAD) Diagnostics Coronary Artery Disease (CAD) remains a leading cause of global mortality. While modern medical facilities generate massive amounts of diagnostic information, current clinical diagnostic workflows suffer from an acute systemic bottleneck: the structural fragmentation of multimodal health data. Physicians are forced to parse patient health datasets across disparate, disconnected systems:

• Tabular Biometric Vectors: Electronic Health Records (EHR) containing statistical biomarkers (e.g., serum cholesterol levels, maximum heart rate achieved, resting blood pressure, ST-segment depression profiles).
• Spatial/Imaging Data: Imaging reports or static cardiac scans that map physical, structural configurations.

The Core Problem There is no fluid, immediate translation layer connecting predictive analytics to spatial anomalies. Clinicians must mentally fuse complex statistical probability outputs (e.g., a raw numbers-based machine learning prediction) with actual physical heart anatomy. This heavy cognitive load slows down diagnostic speed, increases the margin for analytical error during patient triage, and reduces a patient's intuitive understanding of their condition.

1. Solution Architecture Machine Learning Architecture: Multi-Target Calibrated Ensemble The machine learning architecture is designed as a decoupled, multi-target ensemble pipeline. Instead of utilizing a single multi-label classifier or a complex neural network, the system deploys four separate, parallel binary classification pipelines. This ensures maximum structural independence and allows each pipeline to optimize its decision boundaries for specific vascular regions. Below is the technical breakdown of the model's internal structural pipeline:

[ Preprocessed Input Feature Vector (X) ] │ ┌────────────────┼────────────────┬────────────────┐ ▼ ▼ ▼ ▼ [ CAD Pipeline ] [ LAD Pipeline ] [ LCX Pipeline ] [ RCA Pipeline ] │ │ │ │ ▼ ▼ ▼ ▼ [Random Forest] [Random Forest] [Random Forest] [Random Forest] │ │ │ │ ▼ ▼ ▼ ▼ [Platt Calibr.] [Platt Calibr.] [Platt Calibr.] [Platt Calibr.] │ │ │ │ ▼ ▼ ▼ ▼ [Conformal Set] [Conformal Set] [Conformal Set] [Conformal Set] │ │ │ │ └────────────────┼────────────────┴────────────────┘ ▼ [ Aggregated Integration Payload: Probabilities + Explanations (SHAP) ]

Architectural Components Breakdown

1. Core Estimator: Stratified Random Forests

   • Type: Bootstrap-aggregated (bagged) decision tree ensembles.
   • Mechanism: Each of the 4 targets (CAD, LAD, LCX, RCA) has its own independent Random Forest estimator.
   • Target Leakage Shielding: The targets themselves are strictly decoupled. When the LAD model trains, the actual structural labels for CAD, LCX, and RCA are explicitly purged from its input tensor matrix to prevent mathematical shortcutting or label leakage.

2. Translation Layer: Platt Probability Calibration

   • The Problem: Standard Random Forests optimize for pure classification accuracy by averaging votes across trees. This mathematically pushes predictive probabilities away from the extremes ($0$ and $1$) and clusters them heavily around the center hyperplane, destroying raw risk fidelity.
   • The Solution: A Platt Calibration layer (Sigmoid-based logistic regression) is wrapped around each Random Forest output. It maps raw, uncalibrated ensemble voting tallies into absolute, reliable probability distributions: This guarantees that a predicted score of 0.842 translates directly to an exact 84.2% true clinical likelihood of stenosis.

3. Risk Routing Layer: Split-Conformal Prediction Sets

   • Mechanism: To provide reliable uncertainty metrics alongside raw probabilities, a conformal prediction layer processes the calibrated outputs.
   • Output: Instead of returning a fragile point prediction, it establishes statistical margins of error. If a patient's vector lands close to the model's high-uncertainty decision hyperplane, the conformal engine flags a wide prediction set. This triggers the Risk-Averse Routing Logic, categorizing the status as Human Audit Mandatory to protect borderline cases from false negatives.
   • Diagnostic Attribution Layer: Permutation SHAP
   • Mechanism: A local explainability engine sits parallel to the inference layer. It calculates Shapley values using localized permutation sampling against a baseline derived from real healthy patients in the Z-Alizadeh Sani matrix.
   • Output: It breaks down the exact marginal contribution of each biometric input vector (e.g., Oldpeak, Cholesterol) in absolute probability points, giving clinicians a transparent mathematical breakdown of why an artery was flagged as high risk.

4. System Effectiveness Model turns raw statistical outputs into actionable, real-time insights, improving workflows in several key areas:

   • Elimination of Cognitive Context-Switching: Clinicians no longer have to cross-reference data tables alongside separate static medical diagrams. HeartAI visualizes statistical predictions directly onto an interactive 3D model.
   • Instantaneous Parametric Mapping: The 3D render thread handles input data changes seamlessly. Shifting a patient slider (such as elevating fasting blood sugar or oldpeak stress metrics) instantly scales and shifts color gradients on the 3D model, highlighting potential cardiovascular risks right away.
   • Enhanced Patient-Physician Communication: Transforming an abstract risk factor into a clear, color-coded 3D model helps patients intuitively understand their diagnosis, leading to faster treatment decisions and higher compliance rates.
   • Low Computational Footprint: By using React Three Fiber and WebGL, the 3D rendering is hardware-accelerated and runs at a smooth 60 FPS on standard web browsers without requiring expensive GPU servers.

5. Performance Metrics The backend predictive model (cad_bundle.joblib) was trained using historical structured patient metrics stored in dataset.csv. The evaluation pipeline recorded these performance metrics inside backend/models/metrics.json: | Metric Benchmark Category | Target Accomplished Value | Clinical Diagnostic Significance | |---|---|---| | Model Classification Accuracy | 91.48% | Represents high precision in separating true CAD instances from healthy baseline patient biometrics. | | Sensitivity (Recall Rate) | 93.10% | Crucial for clinical safety; minimizes false negatives to ensure high-risk cases are not overlooked. | | Specificity Score | 89.65% | Maximizes true negative classifications, protecting healthy individuals from unnecessary stress and redundant treatments. | | F1-Score Metrics Harmonization | 92.31% | Verifies excellent precision-recall balance, proving the engine remains stable even when working with asymmetrical datasets. | | ROC-AUC (Area Under Curve) | 0.954 | Demonstrates outstanding discriminatory capability across diverse clinical threshold conditions. |

6. User Input to Output Workflow The life cycle of an analytical check on HeartAI follows a rigorous 5-stage end-to-end telemetry pipeline: [ Clinician Input UI ] ──(1) JSON Payload──> [ FastAPI Endpoint ] ──(2) Inference Array ──> [ Serialized ML Model ] │ [ 3D WebGL Canvas View ] <──(5) 60 FPS Mutation── [ Three.js Engine ] <──(4) Target Scale/Color ────┘

Step 1: Clinical Input Ingestion (Client)

• Action: The clinician logs onto the dashboard and inputs the patient's quantitative biometric markers (e.g., Blood Pressure, Serum Cholesterol, ST-segment depression profiles, and demographic records) into the intuitive React view interface (App.jsx).
• Trigger: Clicking the "Execute Diagnostics Pipeline" button locks the UI thread form validation and bundles the inputs.
• Data Payload Transmitted: An asynchronous HTTP POST request pushes an explicit structured JSON structure to the remote cloud server endpoint:

{ "age": 58, "resting_bp": 130, "cholesterol": 245, "oldpeak": 2.3 }

Step 2: Vector Normalization & Endpoint Ingestion (API Backend)

• Action: The REST API backend (main.py routing router) intercepts the inbound JSON file stream package securely.
• Processing: The application payload is passed down into the service pipeline matrix layer (service.py), where fields are vectorized into structured NumPy flat tensor data matrices suitable for analytical machine model evaluation.

Step 3: Machine Learning Inference Array Evaluation (Model Engine)

• Action: The system wakes up the pre-compiled cad_bundle.joblib binary model currently sleeping inside the operational server memory cache.
• Execution: The inference engine maps the input array values against its mathematical training boundaries, calculating a precise decimal value for structural risk probability (0.00 to 1.00).
• Feature Importance Weights Compilation: The model determines which input variables impacted the score the most to generate target spatial distortion factors.

Step 4: Response Schema Package Assembly (Network Response)

• Action: FastAPI serializes the diagnostic engine calculations into an integration telemetry schema payload package.
• Data Payload Returned: An explicit mapping blueprint configuration object is pushed down back across the open HTTP connection tunnel to the client app:

{ "cad_probability": 0.842, "risk_status": "High Risk", "spatial_scale_factor": 1.35, "target_color_map": "0xff0033" }

Step 5: Dynamic 3D Geometric Mutation Loop (Visual Output Generation)

• Action: The web-client frontend architecture intercepts the return network schema packet and updates the local application state variables.
• Processing: The configuration parameters (spatial_scale_factor and target_color_map) are immediately piped down into the Three.js rendering pipeline component (CardiacMesh.jsx).
• Visual Output Presentation: The WebGL engine dynamically mutates the 3D heart asset inside the viewport at a hardware-accelerated 60 FPS:
• Geometric Scaling: The scale factors expand the mesh dimensions locally to visualize physical tissue strain or vascular restriction intensity.
  • Color Mapping: Shaders blend the structural texture profiles instantly into a deep, warning crimson red (0xff0033), immediately communicating high clinical urgency to the attending provider.

Built With

• kaggle
• python-package-index
• vscode