Create app.py

app.py

@@ -0,0 +1,1087 @@
+import pandas as pd
+import numpy as np
+import joblib
+import shap
+import json
+import plotly
+import plotly.graph_objs as go
+import plotly.express as px
+from flask import Flask, render_template, request, jsonify
+import math
+import networkx as nx
+import traceback # For detailed error logging
+import os # For environment variables
+
+app = Flask(__name__)
+
+# --- Load Models ---
+MODEL_PATH_NA = 'non-adherence_XAI.pkl'
+MODEL_PATH_R = 'readmission_XAI.pkl'
+try:
+    model_na = joblib.load(MODEL_PATH_NA)
+    model_r = joblib.load(MODEL_PATH_R)
+    print("Models loaded successfully.")
+    if not (hasattr(model_na, 'predict') and not hasattr(model_na, 'predict_proba')):
+        print(f"Warning: Model {MODEL_PATH_NA} might not be a regressor.")
+    if not (hasattr(model_r, 'predict') and not hasattr(model_r, 'predict_proba')):
+        print(f"Warning: Model {MODEL_PATH_R} might not be a regressor.")
+
+except FileNotFoundError as e:
+    print(f"FATAL ERROR: Model file not found: {e}. Make sure the .pkl files are in the correct directory.")
+    print("Attempted paths:", os.path.abspath(MODEL_PATH_NA), os.path.abspath(MODEL_PATH_R))
+    exit()
+except Exception as e:
+    print(f"FATAL ERROR: An unexpected error occurred loading models: {e}")
+    traceback.print_exc()
+    exit()
+
+# --- Mappings ---
+gender_map = {'Female': 0, 'Male': 1}
+why_map = {
+    'Bone': 0, 'Brain': 1, 'Heart': 2, 'Infection': 3,
+    'Lung': 4, 'Stomach': 5, 'Surgery': 6
+}
+yes_no_map = {'Yes': 1, 'No': 0}
+reverse_gender_map = {v: k for k, v in gender_map.items()}
+reverse_why_map = {v: k for k, v in why_map.items()}
+reverse_yes_no_map = {v: k for k, v in yes_no_map.items()}
+
+# --- Feature Order (Crucial for model input) ---
+feature_order = [
+    'Age', 'Gender', 'Why in Hospital', 'Hospital Days', 'Was in ICU (1=Yes)',
+    'ICU Days', 'Number of Medicines', 'Cost per Medicine (₹)', 'Days Medicine Lasts',
+    'Total Dosage per Day (mg)', 'Total Pills Given', 'Medicine Availability (0-1)',
+    'Took Medicine Day 1 (1=Yes)', 'Took Medicine Day 2 (1=Yes)', 'Took Medicine Day 3 (1=Yes)'
+]
+
+# --- Risk Level Logic ---
+def get_risk_level(score):
+    """Categorizes risk score into Low, Medium, High."""
+    try:
+        clamped_score = max(0.0, min(1.0, float(score)))
+    except (ValueError, TypeError):
+        print(f"Warning: Invalid score '{score}' received. Defaulting to 0.")
+        clamped_score = 0.0
+
+    percentage = round(clamped_score * 100)
+    if clamped_score < 0.3:
+        return {'level': 'Low', 'color': 'green', 'percentage': f"{percentage}%"}
+    elif clamped_score < 0.7:
+        return {'level': 'Medium', 'color': 'yellow', 'percentage': f"{percentage}%"}
+    else:
+        return {'level': 'High', 'color': 'red', 'percentage': f"{percentage}%"}
+
+# --- Feature Metadata for UI ---
+# (Keep the feature_info dictionary as it was in the previous version)
+feature_info = {
+    'Age': {
+        'description': 'Patient age in years',
+        'question': 'How old is the patient?',
+        'help_text': 'Age is a significant factor in both medication adherence and hospital readmission risk.',
+        'ideal_range': '18-100', 'type': 'number'
+    },
+    'Gender': {
+        'description': 'Patient gender',
+        'question': 'What is the patient\'s gender?',
+        'help_text': 'Gender can influence medication adherence patterns and readmission risk for certain conditions.',
+        'options': list(gender_map.keys()), 'type': 'select'
+    },
+    'Why in Hospital': {
+        'description': 'Primary reason for hospitalization',
+        'question': 'What is the primary reason for hospitalization?',
+        'help_text': 'Different conditions have varying impacts on adherence and readmission patterns.',
+        'options': list(why_map.keys()), 'type': 'select'
+    },
+    'Hospital Days': {
+        'description': 'Total days spent in hospital during this admission',
+        'question': 'How many days did the patient spend in the hospital?',
+        'help_text': 'Longer hospital stays often correlate with more complex cases and higher readmission risks.',
+        'ideal_range': '1-30', 'type': 'number'
+    },
+    'Was in ICU (1=Yes)': {
+        'description': 'Whether patient spent time in ICU',
+        'question': 'Did the patient spend time in the ICU?',
+        'help_text': 'ICU stays indicate higher severity and may impact post-discharge outcomes.',
+        'options': list(yes_no_map.keys()), 'type': 'select'
+    },
+    'ICU Days': {
+        'description': 'Total days spent in ICU (if applicable)',
+        'question': 'How many days did the patient spend in the ICU? (Enter 0 if not in ICU)',
+        'help_text': 'Longer ICU stays typically indicate more severe conditions requiring careful post-discharge planning.',
+        'ideal_range': '0-15', 'type': 'number'
+    },
+    'Number of Medicines': {
+        'description': 'Total number of different medications prescribed',
+        'question': 'How many different medications is the patient prescribed?',
+        'help_text': 'Higher medication counts increase complexity and can lead to reduced adherence.',
+        'ideal_range': '1-12', 'type': 'number'
+    },
+    'Cost per Medicine (₹)': {
+        'description': 'Average cost per medication in rupees',
+        'question': 'What is the average cost per medication (in ₹)?',
+        'help_text': 'Higher medication costs can impact adherence due to financial constraints.',
+        'ideal_range': '10-1000', 'type': 'number'
+    },
+    'Days Medicine Lasts': {
+        'description': 'Number of days the prescribed medication will last',
+        'question': 'How many days will the prescribed medication last?',
+        'help_text': 'Longer durations between refills can affect adherence patterns.',
+        'ideal_range': '7-90', 'type': 'number'
+    },
+    'Total Dosage per Day (mg)': {
+        'description': 'Total medication dosage per day in milligrams',
+        'question': 'What is the total medication dosage per day (in mg)?',
+        'help_text': 'Higher daily dosages may indicate more severe conditions and can affect adherence.',
+        'ideal_range': '5-500', 'type': 'number'
+    },
+    'Total Pills Given': {
+        'description': 'Total number of pills provided at discharge',
+        'question': 'How many total pills were given to the patient?',
+        'help_text': 'Pill burden is a known factor in medication adherence.',
+        'ideal_range': '10-300', 'type': 'number'
+    },
+    'Medicine Availability (0-1)': {
+        'description': 'Availability score of prescribed medication (0=low, 1=high)',
+        'question': 'How available is the medication (0=low, 1=high)?',
+        'help_text': 'Limited availability can significantly impact medication adherence.',
+        'ideal_range': '0-1', 'type': 'number', 'step': '0.01' # Specify step for float input
+    },
+    'Took Medicine Day 1 (1=Yes)': {
+        'description': 'Whether patient took medication on day 1 post-discharge',
+        'question': 'Did the patient take their medication on day 1 after discharge?',
+        'help_text': 'Early adherence patterns are strong predictors of overall medication adherence.',
+        'options': list(yes_no_map.keys()), 'type': 'select'
+    },
+    'Took Medicine Day 2 (1=Yes)': {
+        'description': 'Whether patient took medication on day 2 post-discharge',
+        'question': 'Did the patient take their medication on day 2 after discharge?',
+        'help_text': 'Consistent adherence in the first days after discharge indicates better overall adherence.',
+        'options': list(yes_no_map.keys()), 'type': 'select'
+    },
+    'Took Medicine Day 3 (1=Yes)': {
+        'description': 'Whether patient took medication on day 3 post-discharge',
+        'question': 'Did the patient take their medication on day 3 after discharge?',
+        'help_text': 'Patterns established in the first few days often continue throughout treatment.',
+        'options': list(yes_no_map.keys()), 'type': 'select'
+    }
+}
+
+# --- Risk Explanations for UI ---
+# (Keep the risk_explanations dictionary as it was)
+risk_explanations = {
+    'non_adherence': {
+        'title': 'Medication Non-Adherence Risk',
+        'description': 'Medication non-adherence refers to the degree to which a patient does not follow their prescription medication regimen as directed by their healthcare provider. This includes missing doses, taking incorrect doses, or stopping treatment early.',
+        'levels': {
+            'Low': 'Patient is likely to follow medication regimen as prescribed with minimal intervention needed.',
+            'Medium': 'Patient may need additional support such as reminders or follow-up calls to ensure adherence.',
+            'High': 'Patient is at significant risk of not taking medications as prescribed. Consider intensive interventions and close monitoring.'
+        },
+        'consequences': [
+            'Reduced treatment effectiveness', 'Disease progression or complications',
+            'Increased hospitalization rates', 'Higher healthcare costs', 'Poorer health outcomes'
+        ],
+        'interventions': [
+            'Medication reminder systems', 'Simplified medication regimens',
+            'Patient education on importance of adherence', 'Regular follow-up calls',
+            'Addressing barriers (financial, logistical, etc.)'
+        ]
+    },
+    'readmission': {
+        'title': 'Hospital Readmission Risk',
+        'description': 'Hospital readmission risk refers to the likelihood that a patient will need to return to the hospital within a short period (typically 30 days) after being discharged.',
+        'levels': {
+            'Low': 'Patient has minimal risk factors for readmission and can likely be managed with standard follow-up care.',
+            'Medium': 'Patient has moderate risk of readmission and may benefit from enhanced discharge planning and follow-up.',
+            'High': 'Patient is at high risk for readmission and requires comprehensive discharge planning, early follow-up, and possibly home health services.'
+        },
+        'consequences': [
+            'Increased patient suffering', 'Higher healthcare costs', 'Potential complications',
+            'Disruption to patient recovery', 'Reduced hospital quality metrics'
+        ],
+        'interventions': [
+            'Comprehensive discharge planning', 'Medication reconciliation',
+            'Early (within 7 days) follow-up appointments', 'Home health services when appropriate',
+            'Patient and caregiver education'
+        ]
+    }
+}
+
+
+# --- SHAP Explainer Initialization ---
+# (Keep the get_shap_explainer function as it was)
+shap_explainers = {}
+def get_shap_explainer(model_key, model):
+    """Gets or creates a SHAP explainer for a given model."""
+    global shap_explainers
+    if model_key not in shap_explainers:
+        print(f"Initializing SHAP explainer for {model_key}...")
+        try:
+            if hasattr(model, 'feature_importances_') or 'xgboost' in str(type(model)).lower():
+                 explainer = shap.TreeExplainer(model)
+                 shap_explainers[model_key] = explainer
+                 print(f"SHAP TreeExplainer for {model_key} initialized.")
+            else:
+                 print(f"Warning: Model for {model_key} might not be a tree model. Using generic SHAP Explainer.")
+                 try:
+                      explainer = shap.Explainer(model)
+                      shap_explainers[model_key] = explainer
+                      print(f"Initialized generic SHAP Explainer for {model_key}.")
+                 except Exception as gen_e:
+                     print(f"ERROR initializing generic SHAP explainer for {model_key}: {gen_e}")
+                     return None
+        except Exception as e:
+            print(f"ERROR initializing SHAP Explainer for {model_key}: {e}")
+            traceback.print_exc()
+            return None
+    return shap_explainers.get(model_key)
+
+
+# --- Flask Routes ---
+@app.route('/')
+def home():
+    """Renders the main input form page."""
+    return render_template('index.html', feature_info=feature_info, feature_order=feature_order, risk_explanations=risk_explanations)
+
+@app.route('/predict', methods=['POST'])
+def predict():
+    """Handles prediction requests, generates explanations, and returns JSON."""
+    try:
+        data = request.get_json()
+        if not data:
+            return jsonify({'success': False, 'error': 'No data received'}), 400
+        print("Received data:", data)
+
+        # --- Input Processing and Validation ---
+        user_input = {}
+        # Use the more robust key mapping based on getFieldId in JS
+        js_key_map = {
+            'age': 'Age', 'gender': 'Gender', 'why-in-hospital': 'Why in Hospital',
+            'hospital-days': 'Hospital Days', 'was-in-icu-1yes': 'Was in ICU (1=Yes)',
+            'icu-days': 'ICU Days', 'number-of-medicines': 'Number of Medicines',
+            'cost-per-medicine-rupees': 'Cost per Medicine (₹)', 'days-medicine-lasts': 'Days Medicine Lasts',
+            'total-dosage-per-day-mg': 'Total Dosage per Day (mg)', 'total-pills-given': 'Total Pills Given',
+            'medicine-availability-0-1': 'Medicine Availability (0-1)',
+            'took-medicine-day-1-1yes': 'Took Medicine Day 1 (1=Yes)',
+            'took-medicine-day-2-1yes': 'Took Medicine Day 2 (1=Yes)',
+            'took-medicine-day-3-1yes': 'Took Medicine Day 3 (1=Yes)'
+        }
+
+        missing_features = []
+        invalid_features = {}
+
+        # Get 'Was in ICU' value first for conditional validation
+        was_icu_js_key = 'was-in-icu-1yes'
+        was_icu_value_str = data.get(was_icu_js_key, '').capitalize()
+
+        for js_key, feature in js_key_map.items():
+            if feature not in feature_order:
+                print(f"Warning: Feature '{feature}' from js_key_map not in expected feature_order list.")
+                continue
+
+            is_icu_days = (feature == 'ICU Days')
+            is_icu_no = (was_icu_value_str == 'No')
+
+            # Handle missing values
+            if js_key not in data or data[js_key] is None or str(data[js_key]).strip() == '':
+                 # ICU days is allowed to be missing/empty only if Was in ICU is 'No'
+                 if is_icu_days and is_icu_no:
+                     user_input[feature] = 0.0 # Default to 0
+                     print(f"Setting ICU Days to 0 as Was in ICU is No.")
+                     continue
+                 else:
+                     missing_features.append(feature)
+                     continue
+
+            value = data[js_key]
+            f_info = feature_info.get(feature)
+            if not f_info:
+                 print(f"Warning: No feature_info found for '{feature}'. Skipping.")
+                 continue
+
+            try:
+                # Type conversion and mapping
+                if f_info['type'] == 'number':
+                    # Specific check for ICU Days if Was in ICU is Yes
+                    if is_icu_days and not is_icu_no and float(value) < 0:
+                         invalid_features[feature] = "ICU Days cannot be negative if patient was in ICU."
+                    elif is_icu_days and is_icu_no and float(value) != 0:
+                         # If they entered a non-zero value but said No ICU, force to 0
+                         user_input[feature] = 0.0
+                         print(f"Warning: Forcing ICU Days to 0 because Was in ICU is No, but user entered {value}.")
+                    else:
+                         user_input[feature] = float(value)
+
+                elif f_info['type'] == 'select':
+                    lookup_value = value.capitalize() if feature in ['Was in ICU (1=Yes)',
+                                                                        'Took Medicine Day 1 (1=Yes)',
+                                                                        'Took Medicine Day 2 (1=Yes)',
+                                                                        'Took Medicine Day 3 (1=Yes)'] else value
+                    mapped_value = None
+                    if feature == 'Gender': mapped_value = gender_map.get(lookup_value)
+                    elif feature == 'Why in Hospital': mapped_value = why_map.get(lookup_value)
+                    elif feature in ['Was in ICU (1=Yes)', 'Took Medicine Day 1 (1=Yes)',
+                                     'Took Medicine Day 2 (1=Yes)', 'Took Medicine Day 3 (1=Yes)']:
+                         mapped_value = yes_no_map.get(lookup_value)
+
+                    if mapped_value is None:
+                        invalid_features[feature] = f"Invalid option: '{value}'"
+                    else:
+                        user_input[feature] = mapped_value
+                else:
+                    invalid_features[feature] = f"Unknown feature type: '{f_info['type']}'"
+
+            except (ValueError, TypeError) as e:
+                invalid_features[feature] = f"Invalid format for value '{value}': {e}"
+
+        # Handle Validation Errors
+        if missing_features:
+             return jsonify({'success': False, 'error': f"Missing input for: {', '.join(missing_features)}"}), 400
+        if invalid_features:
+             error_msg = "; ".join([f"{k}: {v}" for k,v in invalid_features.items()])
+             return jsonify({'success': False, 'error': f"Invalid input: {error_msg}"}), 400
+
+        # Ensure all features are present before creating DataFrame
+        if len(user_input) != len(feature_order):
+             provided = set(user_input.keys())
+             expected = set(feature_order)
+             missing = list(expected - provided)
+             extra = list(provided - expected)
+             err = f"Feature mismatch after processing. Missing: {missing}. Extra: {extra}."
+             print(f"ERROR: {err}")
+             return jsonify({'success': False, 'error': f"Internal error: Feature mismatch. Please check processing logic. Missing: {missing}"}), 500
+
+        # Create DataFrame in the correct order
+        df_user = pd.DataFrame([user_input], columns=feature_order)
+        print("Processed DataFrame for prediction:\n", df_user.to_string())
+
+        # --- Model Predictions ---
+        pred_na_raw = model_na.predict(df_user)[0]
+        pred_r_raw  = model_r.predict(df_user)[0]
+        pred_na_score = max(0.0, min(1.0, float(pred_na_raw)))
+        pred_r_score = max(0.0, min(1.0, float(pred_r_raw)))
+        print(f"Predictions - NA Score: {pred_na_score:.4f}, R Score: {pred_r_score:.4f}")
+        risk_level_na = get_risk_level(pred_na_score)
+        risk_level_r  = get_risk_level(pred_r_score)
+
+        # --- SHAP Explanations ---
+        # (Keep the SHAP calculation block largely the same as previous version,
+        # ensuring base_value_na/r and shap_error_na/r are set correctly)
+        shap_explainer_na = get_shap_explainer('non_adherence', model_na)
+        shap_explainer_r  = get_shap_explainer('readmission', model_r)
+        shap_data_na = []
+        shap_data_r = []
+        base_value_na = None
+        base_value_r = None
+        shap_error_na = False
+        shap_error_r = False
+
+        # Calculate SHAP NA
+        if shap_explainer_na:
+            try:
+                shap_values_na = shap_explainer_na.shap_values(df_user)
+                shap_vec_na = None
+                if isinstance(shap_values_na, list): shap_vec_na = shap_values_na[0][0] # Multi-output?
+                elif isinstance(shap_values_na, np.ndarray) and shap_values_na.ndim == 2: shap_vec_na = shap_values_na[0]
+                elif isinstance(shap_values_na, np.ndarray) and shap_values_na.ndim == 1: shap_vec_na = shap_values_na
+                else: raise TypeError(f"Unexpected SHAP NA format: {type(shap_values_na)}")
+
+                ev_na = shap_explainer_na.expected_value
+                if isinstance(ev_na, (list, np.ndarray)): base_value_na = float(ev_na[0])
+                elif ev_na is not None: base_value_na = float(ev_na)
+                else: base_value_na = 0.5; print("Warning: SHAP NA expected_value is None. Using 0.5.")
+
+                if shap_vec_na is not None and len(shap_vec_na) == len(feature_order):
+                    print(f"SHAP NA: Base={base_value_na:.4f}, Sum={np.sum(shap_vec_na):.4f}, Pred={pred_na_score:.4f}, Total={base_value_na + np.sum(shap_vec_na):.4f}")
+                    for i, feature in enumerate(feature_order):
+                        orig_js_key = next((k for k, v in js_key_map.items() if v == feature), None)
+                        orig_val = data.get(orig_js_key, "N/A")
+                        f_info = feature_info.get(feature, {})
+                        shap_data_na.append({
+                            'feature': feature, 'shap_value': float(shap_vec_na[i]),
+                            'feature_value': str(orig_val), 'numeric_value': float(df_user.iloc[0, i]),
+                            'description': f_info.get('description', ''), 'help_text': f_info.get('help_text', '')
+                        })
+                    shap_data_na.sort(key=lambda x: abs(x.get('shap_value', 0)), reverse=True)
+                else: raise ValueError(f"SHAP NA vector length mismatch or None.")
+            except Exception as e:
+                 print(f"Error calculating SHAP NA: {e}"); traceback.print_exc()
+                 shap_data_na = [{"error": "Could not calculate SHAP values for Non-Adherence."}]
+                 base_value_na = 0.5; shap_error_na = True
+        else:
+            shap_data_na = [{"error": "SHAP explainer NA not available."}]; base_value_na = 0.5; shap_error_na = True
+
+        # Calculate SHAP R
+        if shap_explainer_r:
+            try:
+                shap_values_r = shap_explainer_r.shap_values(df_user)
+                shap_vec_r = None
+                if isinstance(shap_values_r, list): shap_vec_r = shap_values_r[0][0]
+                elif isinstance(shap_values_r, np.ndarray) and shap_values_r.ndim == 2: shap_vec_r = shap_values_r[0]
+                elif isinstance(shap_values_r, np.ndarray) and shap_values_r.ndim == 1: shap_vec_r = shap_values_r
+                else: raise TypeError(f"Unexpected SHAP R format: {type(shap_values_r)}")
+
+                ev_r = shap_explainer_r.expected_value
+                if isinstance(ev_r, (list, np.ndarray)): base_value_r = float(ev_r[0])
+                elif ev_r is not None: base_value_r = float(ev_r)
+                else: base_value_r = 0.5; print("Warning: SHAP R expected_value is None. Using 0.5.")
+
+                if shap_vec_r is not None and len(shap_vec_r) == len(feature_order):
+                    print(f"SHAP R: Base={base_value_r:.4f}, Sum={np.sum(shap_vec_r):.4f}, Pred={pred_r_score:.4f}, Total={base_value_r + np.sum(shap_vec_r):.4f}")
+                    for i, feature in enumerate(feature_order):
+                         orig_js_key = next((k for k, v in js_key_map.items() if v == feature), None)
+                         orig_val = data.get(orig_js_key, "N/A")
+                         f_info = feature_info.get(feature, {})
+                         shap_data_r.append({
+                             'feature': feature, 'shap_value': float(shap_vec_r[i]),
+                             'feature_value': str(orig_val), 'numeric_value': float(df_user.iloc[0, i]),
+                             'description': f_info.get('description', ''), 'help_text': f_info.get('help_text', '')
+                         })
+                    shap_data_r.sort(key=lambda x: abs(x.get('shap_value', 0)), reverse=True)
+                else: raise ValueError(f"SHAP R vector length mismatch or None.")
+            except Exception as e:
+                 print(f"Error calculating SHAP R: {e}"); traceback.print_exc()
+                 shap_data_r = [{"error": "Could not calculate SHAP values for Readmission."}]
+                 base_value_r = 0.5; shap_error_r = True
+        else:
+            shap_data_r = [{"error": "SHAP explainer R not available."}]; base_value_r = 0.5; shap_error_r = True
+
+        # --- Counterfactuals & Recommendations ---
+        cf_data_na = generate_comprehensive_counterfactuals(df_user, model_na, "Non-Adherence", shap_data_na, shap_error_na)
+        cf_data_r  = generate_comprehensive_counterfactuals(df_user, model_r, "Readmission",  shap_data_r, shap_error_r)
+        recommendations = generate_recommendations(shap_data_na, shap_data_r, pred_na_score, pred_r_score, shap_error_na, shap_error_r)
+
+        # --- Visualizations ---
+        gauges = generate_gauge_charts(pred_na_score, pred_r_score)
+        additional_visualizations = generate_additional_visualizations(
+            df_user, shap_data_na, shap_data_r, base_value_na, base_value_r, shap_error_na, shap_error_r
+        )
+
+        # --- Response ---
+        response = {
+            'success': True,
+            'predictions': {
+                'non_adherence': round(pred_na_score, 3),
+                'readmission': round(pred_r_score, 3),
+                'risk_level_na': risk_level_na,
+                'risk_level_r': risk_level_r,
+                'base_value_na': round(base_value_na, 3) if base_value_na is not None else None,
+                'base_value_r': round(base_value_r, 3) if base_value_r is not None else None
+            },
+            'explanations': {
+                'shap_values_na': shap_data_na,
+                'shap_values_r': shap_data_r,
+                'counterfactuals_na': cf_data_na,
+                'counterfactuals_r': cf_data_r,
+                'shap_error_na': shap_error_na,
+                'shap_error_r': shap_error_r
+            },
+            'recommendations': recommendations,
+            'visualizations': {
+                'gauges': gauges,
+                'additional': additional_visualizations
+            }
+        }
+        return jsonify(response)
+
+    # Error Handling remains the same as previous version
+    except ValueError as ve:
+        print(f"Value Error during prediction processing: {ve}")
+        traceback.print_exc()
+        return jsonify({'success': False, 'error': f"Invalid input: {str(ve)}"}), 400
+    except KeyError as ke:
+         print(f"Key Error during prediction processing: {ke}")
+         traceback.print_exc()
+         return jsonify({'success': False, 'error': f"Missing expected data field: {str(ke)}"}), 400
+    except Exception as e:
+        print(f"An unexpected error occurred during prediction: {e}")
+        traceback.print_exc()
+        return jsonify({'success': False, 'error': "An internal server error occurred. Please try again later."}), 500
+
+
+# --- Placeholder JSON for Plots on Error ---
+# (Keep create_placeholder_plot as it was)
+def create_placeholder_plot(title_suffix, message="Required data not available for this chart."):
+    """Creates JSON for a placeholder plot indicating data unavailability."""
+    return json.dumps({
+        'data': [],
+        'layout': {
+            'title': f'{title_suffix} (Not Generated)',
+            'xaxis': {'visible': False},
+            'yaxis': {'visible': False},
+            'annotations': [{
+                'text': message,
+                'xref': 'paper', 'yref': 'paper',
+                'x': 0.5, 'y': 0.5, 'showarrow': False,
+                'font': {'size': 12, 'color': '#888'}
+            }],
+            'plot_bgcolor': 'rgba(0,0,0,0)',
+            'paper_bgcolor': 'rgba(0,0,0,0)'
+        }
+    }, cls=plotly.utils.PlotlyJSONEncoder)
+
+# --- Counterfactual Generation ---
+# (Keep generate_comprehensive_counterfactuals as it was)
+def generate_comprehensive_counterfactuals(df_original, model, target_type, shap_data, shap_error):
+    """Generate simplified counterfactuals based on SHAP values and feature modifiability."""
+    print(f"Generating counterfactuals for {target_type}...")
+    counterfactuals = []
+    if shap_error or not isinstance(shap_data, list) or not shap_data or (shap_data[0] and shap_data[0].get("error")):
+         print(f"Skipping counterfactuals for {target_type} due to SHAP errors or missing data.")
+         return [{"error": f"Could not generate counterfactuals for {target_type} because SHAP data is missing or invalid."}]
+
+    df = df_original.copy()
+    try:
+        current_pred_score = max(0.0, min(1.0, float(model.predict(df)[0])))
+        goal_direction = "decrease"
+        non_modifiable_features = {"Age", "Gender", "Why in Hospital", "Hospital Days", "Was in ICU (1=Yes)", "ICU Days"}
+        valid_shap_data = [item for item in shap_data if "error" not in item]
+        shap_data_sorted = sorted(valid_shap_data, key=lambda x: abs(x.get('shap_value', 0)), reverse=True)
+        cf_count = 0
+        max_cfs = 5
+
+        for feature_data in shap_data_sorted:
+            if cf_count >= max_cfs: break
+            feature = feature_data.get('feature')
+            shap_value = feature_data.get('shap_value', 0)
+            current_display_value = feature_data.get('feature_value', 'N/A')
+            original_numeric_value = feature_data.get('numeric_value')
+
+            if feature is None or original_numeric_value is None or abs(shap_value) < 0.01 or feature in non_modifiable_features:
+                continue
+
+            feature_change_direction = "decrease" if shap_value > 0 else "increase"
+            could_change = False
+            new_value = None
+            suggested_val_str = ""
+            potential_outcome = "N/A"
+            notes = ""
+            impact_magnitude = "Minor"
+
+            # --- Specific Logic for Modifiable Features ---
+            if feature.startswith("Took Medicine Day"):
+                if original_numeric_value == 0 and shap_value > 0.01:
+                    suggested_val_str = "Ensure Adherence ('Yes')"
+                    new_value = 1
+                    could_change = True
+            elif feature == "Medicine Availability (0-1)":
+                if shap_value < -0.01 and original_numeric_value < 0.95:
+                     new_value = 1.0
+                     suggested_val_str = "Improve towards High (1.0)"
+                     could_change = True
+            else: # Other numeric modifiable features
+                if (feature_change_direction == "decrease" and shap_value > 0.02) or \
+                   (feature_change_direction == "increase" and shap_value < -0.02):
+                    change_perc = 0.20
+                    target_factor = (1 - change_perc) if feature_change_direction == "decrease" else (1 + change_perc)
+                    tentative_new_value = original_numeric_value * target_factor
+
+                    # Apply constraints and rounding
+                    if feature in ["Number of Medicines", "Total Pills Given"]: new_value = max(1, math.floor(tentative_new_value))
+                    elif feature == "Days Medicine Lasts": new_value = max(7, math.floor(tentative_new_value))
+                    elif feature == "Cost per Medicine (₹)": new_value = max(10.0, round(tentative_new_value, 0))
+                    elif feature == "Total Dosage per Day (mg)": new_value = max(5.0, round(tentative_new_value, 0))
+                    else: new_value = round(tentative_new_value, 2) # Fallback
+
+                    # Generate suggested string AFTER setting new_value
+                    if feature == "Number of Medicines": suggested_val_str = f"{feature_change_direction.capitalize()} towards ~{int(new_value)}"
+                    elif feature == "Total Pills Given": suggested_val_str = f"{feature_change_direction.capitalize()} towards ~{int(new_value)}"
+                    elif feature == "Days Medicine Lasts": suggested_val_str = f"{feature_change_direction.capitalize()} towards ~{int(new_value)} days"
+                    elif feature == "Cost per Medicine (₹)": suggested_val_str = f"{feature_change_direction.capitalize()} towards ~₹{new_value:.0f}"
+                    elif feature == "Total Dosage per Day (mg)": suggested_val_str = f"{feature_change_direction.capitalize()} towards ~{new_value:.0f} mg"
+                    else: suggested_val_str = f"{feature_change_direction.capitalize()} towards ~{new_value:.2f}"
+
+
+                    # Check if change is significant
+                    if abs(new_value - original_numeric_value) > 0.01 * abs(original_numeric_value) + 0.1:
+                        could_change = True
+                    else:
+                        new_value = None # Don't simulate small changes
+
+            # --- Simulate Outcome ---
+            if could_change and new_value is not None and suggested_val_str:
+                df_cf = df.copy(); df_cf[feature] = new_value
+                try:
+                    cf_pred_score = max(0.0, min(1.0, float(model.predict(df_cf)[0])))
+                    change_in_score = cf_pred_score - current_pred_score
+                    outcome_desc = f"Est. new risk: {cf_pred_score:.1%}"
+                    change_desc = f"({change_in_score:+.1%})"
+
+                    if (goal_direction == "decrease" and change_in_score < -0.01):
+                        potential_outcome = f"{outcome_desc} {change_desc}"
+                        if abs(change_in_score) > 0.10: impact_magnitude = "Significant"
+                        elif abs(change_in_score) > 0.05: impact_magnitude = "Moderate"
+                        notes = f"This change is predicted to {goal_direction} the {target_type.lower()} risk."
+                        counterfactuals.append({
+                            "feature": feature, "current_value": current_display_value,
+                            "suggested_change": suggested_val_str, "potential_outcome": potential_outcome,
+                            "impact_magnitude": impact_magnitude, "risk_type": target_type
+                        })
+                        cf_count += 1
+                except Exception as sim_e:
+                    print(f"Error simulating counterfactual for {feature}: {sim_e}")
+
+        if not counterfactuals:
+             counterfactuals.append({"notes": f"No simple, impactful counterfactual changes identified among top modifiable factors for {target_type} risk."})
+        print(f"Finished generating {cf_count} counterfactual entries for {target_type}.")
+        return counterfactuals
+    except Exception as e:
+        print(f"Error generating counterfactuals for {target_type}: {str(e)}")
+        traceback.print_exc()
+        return [{"error": f"Could not generate counterfactuals for {target_type}: {str(e)}"}]
+
+# --- Recommendation Generation ---
+# (Keep generate_recommendations as it was)
+def generate_recommendations(shap_data_na, shap_data_r, pred_na_prob, pred_r_prob, shap_error_na, shap_error_r):
+    """Generate actionable recommendations based on risk levels and SHAP factors."""
+    print("Generating recommendations...")
+    recommendations = []
+    processed_features = set()
+
+    na_shap_valid = not shap_error_na and isinstance(shap_data_na, list) and shap_data_na and "error" not in shap_data_na[0]
+    r_shap_valid = not shap_error_r and isinstance(shap_data_r, list) and shap_data_r and "error" not in shap_data_r[0]
+
+    na_risk_level_info = get_risk_level(pred_na_prob)
+    r_risk_level_info = get_risk_level(pred_r_prob)
+    na_level = na_risk_level_info['level']
+    r_level = r_risk_level_info['level']
+
+    # --- General Recommendations ---
+    if na_level == 'High':
+        recommendations.append({
+            "category": "Overall Non-Adherence", "priority": "Critical",
+            "recommendation": f"High ({na_risk_level_info['percentage']}) non-adherence risk detected.",
+            "action": "Implement intensive adherence support: daily reminders, regimen simplification consult, frequent follow-up (e.g., within 3 days), assess/address specific barriers (cost, access, understanding)."
+        })
+    elif na_level == 'Medium':
+        recommendations.append({
+            "category": "Overall Non-Adherence", "priority": "High",
+            "recommendation": f"Medium ({na_risk_level_info['percentage']}) non-adherence risk detected.",
+            "action": "Provide adherence aids (e.g., pillbox, app reminders), schedule follow-up call within 1 week, reinforce importance of medication."
+        })
+    if r_level == 'High':
+        recommendations.append({
+            "category": "Overall Readmission", "priority": "Critical",
+            "recommendation": f"High ({r_risk_level_info['percentage']}) readmission risk detected.",
+            "action": "Comprehensive discharge plan crucial: schedule follow-up within 7 days, ensure medication reconciliation, consider home health/transitional care referral, detailed patient/caregiver education using teach-back."
+        })
+    elif r_level == 'Medium':
+         recommendations.append({
+            "category": "Overall Readmission", "priority": "High",
+            "recommendation": f"Medium ({r_risk_level_info['percentage']}) readmission risk detected.",
+            "action": "Enhanced discharge process: ensure clear instructions (written/verbal), schedule follow-up within 10-14 days, confirm patient understanding of red flags and who to contact."
+        })
+
+    # --- Specific Recommendations ---
+    if not na_shap_valid and not r_shap_valid:
+        recommendations.append({
+            "category": "Explanations", "priority": "Medium",
+            "recommendation": "Detailed factor analysis unavailable due to SHAP errors.",
+            "action": "Focus on general risk levels and standard protocols. Investigate SHAP calculation issues if persistent."})
+        return recommendations # Early exit
+
+    combined_shap = {}
+    valid_shap_list = ([item for item in shap_data_na if "error" not in item] if na_shap_valid else []) + \
+                      ([item for item in shap_data_r if "error" not in item] if r_shap_valid else [])
+    for item in valid_shap_list:
+        feature = item.get('feature')
+        abs_shap = abs(item.get('shap_value', 0))
+        if feature:
+            current_entry = combined_shap.get(feature, {'abs_shap_sum': 0, 'data_na': None, 'data_r': None})
+            current_entry['abs_shap_sum'] += abs_shap
+            if item in shap_data_na: current_entry['data_na'] = item
+            if item in shap_data_r: current_entry['data_r'] = item
+            combined_shap[feature] = current_entry
+    sorted_features = sorted(combined_shap.keys(), key=lambda f: combined_shap[f]['abs_shap_sum'], reverse=True)
+
+    rec_count = 0
+    max_recs = 7
+    shap_threshold = 0.02 # Minimum SHAP value to consider as a driver
+
+    for feature in sorted_features:
+        if rec_count >= max_recs: break
+        if feature in processed_features: continue
+
+        shap_entry = combined_shap.get(feature, {})
+        na_item = shap_entry.get('data_na')
+        r_item = shap_entry.get('data_r')
+        na_shap = na_item.get('shap_value', 0) if na_item else 0
+        r_shap = r_item.get('shap_value', 0) if r_item else 0
+        item_for_val = na_item or r_item
+        current_val = item_for_val.get('feature_value', 'N/A') if item_for_val else 'N/A'
+        numeric_val = item_for_val.get('numeric_value') if item_for_val else None
+
+        is_na_driver = na_shap > shap_threshold
+        is_r_driver = r_shap > shap_threshold
+        if not (is_na_driver or is_r_driver): continue # Skip if not a driver for either
+
+        max_abs_shap = max(abs(na_shap), abs(r_shap))
+        priority = "Medium"
+        if max_abs_shap > 0.1: priority = "High"
+        if (is_na_driver and na_level == 'High') or (is_r_driver and r_level == 'High'): priority = "High" if priority == "Medium" else priority
+        if (na_level == 'High' and na_shap > 0.15) or (r_level == 'High' and r_shap > 0.15): priority = "Critical"
+
+        rec_made = False
+        action_text = ""
+        rec_category = ""
+        rec_recommendation = ""
+
+        # --- Generate Recommendation Content ---
+        # (Combine NA and R logic for the same feature where applicable)
+        if feature.startswith("Took Medicine Day") and current_val == "No":
+            if is_na_driver: # Primarily an adherence issue
+                 priority = "Critical"; rec_category = "Early Adherence Failure"
+                 rec_recommendation = f"Missed medication on {feature.split('(')[0].strip()} is a strong indicator of future non-adherence."
+                 action_text = "Immediate intervention required: follow-up call TODAY, assess reasons, counsel, establish reminders/support."
+                 rec_made = True
+        elif feature == "Number of Medicines":
+             if is_na_driver or is_r_driver:
+                 rec_category = "Medication Complexity"
+                 rec_recommendation = f"High number of medicines ({current_val}) associated with increased risk ({'NA' if is_na_driver else ''}{'& R' if is_r_driver else ''})."
+                 action_text = "Review list for simplification/consolidation. Consider pharmacist consult for polypharmacy review."
+                 rec_made = True
+        elif feature == "Cost per Medicine (₹)":
+             try: cost_val = float(numeric_val) if numeric_val is not None else 0
+             except: cost_val = 0
+             if cost_val > 100 and is_na_driver: # Primarily adherence cost barrier
+                 rec_category = "Medication Cost Barrier"
+                 rec_recommendation = f"High average medication cost (₹{current_val}) may be a barrier to adherence."
+                 action_text = "Discuss cost concerns. Explore generics, assistance programs, or lower-cost alternatives."
+                 rec_made = True
+        elif feature == "Medicine Availability (0-1)":
+             try: avail_val = float(numeric_val) if numeric_val is not None else 1.0
+             except: avail_val = 1.0
+             if avail_val < 0.5 and is_na_driver: # Primarily adherence access issue
+                 rec_category = "Medication Access Issue"
+                 rec_recommendation = f"Reported low medication availability ({current_val}) likely hinders adherence."
+                 action_text = "Verify pharmacy stock pre-discharge. Help patient identify reliable source or discuss alternatives."
+                 rec_made = True
+        elif feature == "ICU Days":
+             try: icu_days_val = int(numeric_val) if numeric_val is not None else 0
+             except: icu_days_val = 0
+             if icu_days_val > 0 and is_r_driver: # Primarily readmission risk
+                 rec_priority = "High" if icu_days_val > 2 else priority
+                 rec_category = "ICU History Impact"; priority = rec_priority
+                 rec_recommendation = f"Prior ICU stay ({current_val} days) significantly increases readmission risk."
+                 action_text = "Intensive post-discharge support: early follow-up (≤7 days), consider transitional care/home health, meticulous med review & education."
+                 rec_made = True
+        elif feature == "Hospital Days":
+            try: days_val = int(numeric_val) if numeric_val is not None else 0
+            except: days_val = 0
+            if days_val > 7 and is_r_driver: # Primarily readmission risk
+                rec_category = "Length of Stay Impact"
+                rec_recommendation = f"Longer hospital stay ({current_val} days) associated with increased readmission risk."
+                action_text = "Reinforces need for thorough discharge planning, clear instructions, med reconciliation, and prompt follow-up (≤10 days)."
+                rec_made = True
+        elif feature == "Age":
+             try: age_val = int(numeric_val) if numeric_val is not None else 0
+             except: age_val = 0
+             if age_val > 75 and is_r_driver: # Readmission context factor
+                 priority = "Medium"; rec_category = "Age Factor (Context)"
+                 rec_recommendation = f"Patient's age ({current_val}) contributes moderately to readmission risk."
+                 action_text = "Consider age-related needs in discharge plan (support, mobility, cognition, simple instructions)."
+                 rec_made = True
+        elif feature == "Why in Hospital":
+             if is_r_driver: # Readmission context factor
+                 priority = "Medium" if priority=="Standard" else priority # Elevate slightly but not critical usually
+                 rec_category = "Diagnosis Factor (Context)"
+                 rec_recommendation = f"Primary diagnosis ({current_val}) contributes to risk."
+                 action_text = f"Ensure condition-specific discharge education (red flags, follow-up) and care plan for managing '{current_val.lower()}' are emphasized."
+                 rec_made = True
+
+        # Append the recommendation if one was generated
+        if rec_made:
+            recommendations.append({
+                "category": rec_category,
+                "priority": priority,
+                "recommendation": rec_recommendation,
+                "action": action_text
+            })
+            processed_features.add(feature)
+            rec_count += 1
+
+    # Add default recommendation if few specific ones generated but risk elevated
+    if (na_level in ['High', 'Medium'] or r_level in ['High', 'Medium']) and len(recommendations) < 3:
+         recommendations.append({
+             "category": "General Follow-up", "priority": "Medium",
+             "recommendation": "Overall risk is elevated. Review standard discharge protocols.",
+             "action": "Ensure robust basics: use teach-back, confirm follow-up appointments, provide clear contact info."})
+
+    # Sort final recommendations by priority
+    priority_map = {"Critical": 0, "High": 1, "Medium": 2, "Standard": 3, "Info": 4}
+    recommendations.sort(key=lambda x: priority_map.get(x.get("priority", "Medium"), 99))
+
+    print(f"Finished generating {len(recommendations)} recommendations.")
+    return recommendations
+
+
+# --- Visualization Generation ---
+# (Keep generate_gauge_charts as it was)
+def generate_gauge_charts(pred_na_prob, pred_r_prob):
+    """Generate Plotly gauge chart JSON objects."""
+    print("Generating gauge charts...")
+    gauges = {}
+    color_low = '#28a745'; color_medium = '#ffc107'; color_high = '#dc3545'
+    color_low_bg = '#d4edda'; color_medium_bg = '#fff3cd'; color_high_bg = '#f8d7da'
+    pred_na_prob = max(0.0, min(1.0, pred_na_prob))
+    pred_r_prob = max(0.0, min(1.0, pred_r_prob))
+    common_layout = {'height': 220, 'margin': {'t': 50, 'b': 10, 'l': 20, 'r': 20}, 'font': {'color': "#333", 'family': "Arial, sans-serif", 'size': 12}, 'paper_bgcolor': 'rgba(0,0,0,0)', 'plot_bgcolor': 'rgba(0,0,0,0)', 'autosize': True}
+    common_gauge = {'axis': {'range': [0, 100], 'tickwidth': 1, 'tickcolor': "#aaa", 'tickfont': {'size': 10}}, 'bar': {'color': "rgba(0,0,0,0.1)", 'thickness': 0.3}, 'bgcolor': 'rgba(0,0,0,0)', 'borderwidth': 0, 'steps': [{'range': [0, 30], 'color': color_low_bg}, {'range': [30, 70], 'color': color_medium_bg}, {'range': [70, 100], 'color': color_high_bg}], 'threshold': {'line': {'color': '#666', 'width': 4}, 'thickness': 0.75, 'value': 0}}
+
+    na_risk_info = get_risk_level(pred_na_prob)
+    na_value_perc = round(pred_na_prob * 100)
+    na_gauge_data = common_gauge.copy(); na_gauge_data['threshold']['value'] = na_value_perc
+    gauge_bar_color_na = {'green': color_low, 'yellow': color_medium, 'red': color_high}.get(na_risk_info['color'], '#888')
+    na_gauge_data['bar']['color'] = gauge_bar_color_na
+    gauges['non_adherence'] = json.dumps({'data': [{'type': 'indicator', 'mode': 'gauge+number', 'value': na_value_perc, 'title': {'text': f"<b>Non-Adherence Risk</b><br><span style='font-size:0.9em;'>Level: {na_risk_info['level']}</span>", 'font': {'size': 14}}, 'gauge': na_gauge_data, 'number': {'suffix': "%", 'font': {'size': 24, 'color': gauge_bar_color_na}}}], 'layout': common_layout.copy()}, cls=plotly.utils.PlotlyJSONEncoder)
+
+    r_risk_info = get_risk_level(pred_r_prob)
+    r_value_perc = round(pred_r_prob * 100)
+    r_gauge_data = common_gauge.copy(); r_gauge_data['threshold']['value'] = r_value_perc
+    gauge_bar_color_r = {'green': color_low, 'yellow': color_medium, 'red': color_high}.get(r_risk_info['color'], '#888')
+    r_gauge_data['bar']['color'] = gauge_bar_color_r
+    gauges['readmission'] = json.dumps({'data': [{'type': 'indicator', 'mode': 'gauge+number', 'value': r_value_perc, 'title': {'text': f"<b>Readmission Risk</b><br><span style='font-size:0.9em;'>Level: {r_risk_info['level']}</span>", 'font': {'size': 14}}, 'gauge': r_gauge_data, 'number': {'suffix': "%", 'font': {'size': 24, 'color': gauge_bar_color_r}}}], 'layout': common_layout.copy()}, cls=plotly.utils.PlotlyJSONEncoder)
+
+    print("Finished generating gauge charts.")
+    return gauges
+
+
+# In app.py
+def generate_additional_visualizations(df_user, shap_data_na, shap_data_r,
+                                       base_value_na, base_value_r,
+                                       shap_error_na, shap_error_r):
+    """Generate additional Plotly JSON for various XAI visualizations, including
+       waterfall, heatmap, feature comparison, intervention impact, and network graph."""
+    print("Generating additional visualizations...")
+    visualizations = {}
+    plot_bgcolor = 'rgba(0,0,0,0)'
+    paper_bgcolor = 'rgba(0,0,0,0)'
+    font_family = "Arial, sans-serif"
+    font_color = "#333"
+
+    # Determine validity
+    na_shap_valid = not shap_error_na and isinstance(shap_data_na, list) and shap_data_na and "error" not in shap_data_na[0]
+    r_shap_valid  = not shap_error_r  and isinstance(shap_data_r,  list) and shap_data_r  and "error" not in shap_data_r[0]
+
+    # --- 1. Waterfall Charts ---
+    def create_waterfall(shap_data, base_value, title_suffix, is_valid):
+        if not is_valid or base_value is None:
+            return create_placeholder_plot(f'Waterfall: {title_suffix}')
+        try:
+            valid = [item for item in shap_data if isinstance(item, dict) and "error" not in item]
+            top = sorted(valid, key=lambda x: abs(x['shap_value']), reverse=True)[:10]
+            values = [item['shap_value'] for item in top]
+            labels = [
+                f"{item['feature'][:25]}{'...' if len(item['feature'])>25 else ''} = {item['feature_value']}"
+                for item in top
+            ]
+            measures = ["absolute"] + ["relative"]*len(top) + ["total"]
+            y = ["Average Model Output"] + labels + ["Final Prediction"]
+            x = [base_value] + values + [base_value + sum(values)]
+            text = [f"{v:+.3f}" if 0< i < len(x)-1 else f"{v:.3f}" for i, v in enumerate(x)]
+
+            fig = go.Figure(go.Waterfall(
+                orientation="h", measure=measures, y=y, x=x, text=text,
+                textposition="outside", base=0,
+                connector={"line":{"color":"rgb(150,150,150)", "width":1}},
+                increasing={"marker":{"color":"#dc3545","line":{"width":1,"color":"#dc3545"}}},
+                decreasing={"marker":{"color":"#28a745","line":{"width":1,"color":"#28a745"}}},
+                totals={"marker":{"color":"#007bff","line":{"width":1,"color":"#007bff"}}}
+            ))
+            # autoscale axis
+            all_vals = x
+            mn, mx = min(all_vals), max(all_vals)
+            pad = (mx-mn)*0.15 if (mx-mn)>0.01 else 0.1
+            fig.update_layout(
+                title=f'How Factors Contribute to {title_suffix}',
+                showlegend=False,
+                height=max(450,40*len(y)),
+                margin=dict(t=50,l=250,r=50,b=50),
+                yaxis={'autorange':'reversed','automargin':True},
+                xaxis={'range':[mn-pad,mx+pad],'title':'Contribution to Score'},
+                plot_bgcolor=plot_bgcolor,
+                paper_bgcolor=paper_bgcolor,
+                font=dict(family=font_family,color=font_color),
+                autosize=True
+            )
+            return json.dumps(fig, cls=plotly.utils.PlotlyJSONEncoder)
+        except Exception as e:
+            print(f"Error creating waterfall {title_suffix}: {e}")
+            return create_placeholder_plot(f'Waterfall: {title_suffix}')
+
+    visualizations['waterfall_na'] = create_waterfall(shap_data_na, base_value_na, 'Non-Adherence Risk', na_shap_valid)
+    visualizations['waterfall_r']  = create_waterfall(shap_data_r,  base_value_r, 'Readmission Risk',   r_shap_valid)
+
+    # --- 2. Combined SHAP for heatmap & bar chart ---
+    # collect valid shap items
+    valid_na = [i for i in shap_data_na if na_shap_valid and "error" not in i]
+    valid_r  = [i for i in shap_data_r  if r_shap_valid  and "error" not in i]
+    combined_impact = {}
+    for i in (valid_na + valid_r):
+        f=i['feature']; combined_impact[f]=combined_impact.get(f,0)+abs(i['shap_value'])
+    top_feats = sorted(combined_impact, key=lambda f:combined_impact[f], reverse=True)[:10]
+
+    # 2a. Heatmap
+    try:
+        z=[]; text=[]
+        for f in top_feats:
+            na_v = next((i['shap_value'] for i in valid_na if i['feature']==f),0)
+            r_v  = next((i['shap_value'] for i in valid_r  if i['feature']==f),0)
+            z.append([na_v,r_v])
+            fv_na = next((i['feature_value'] for i in valid_na if i['feature']==f),None)
+            fv_r  = next((i['feature_value'] for i in valid_r  if i['feature']==f),None)
+            display = fv_na if fv_na is not None else fv_r
+            text.append([f"<b>{f}={display}</b><br>NA: {na_v:.3f}", f"<b>{f}={display}</b><br>R: {r_v:.3f}"])
+        hm = {
+            'data':[{
+                'type':'heatmap','z':z,'text':text,'hoverinfo':'text',
+                'x':['Non-Adherence','Readmission'],'y':top_feats,
+                'colorscale':'RdBu_r','zmid':0,'xgap':1,'ygap':1
+            }],
+            'layout':{
+                'title':'Top Factor Impact Comparison',
+                'height':max(400,40*len(top_feats)),
+                'margin':{'t':60,'l':250,'b':80,'r':50},
+                'yaxis':{'autorange':'reversed','automargin':True},
+                'plot_bgcolor':plot_bgcolor,'paper_bgcolor':paper_bgcolor,
+                'font':{'family':font_family,'color':font_color},
+                'autosize':True
+            }
+        }
+        visualizations['risk_heatmap']=json.dumps(hm, cls=plotly.utils.PlotlyJSONEncoder)
+    except Exception as e:
+        print(f"Error heatmap: {e}")
+        visualizations['risk_heatmap']=create_placeholder_plot('Risk Factor Heatmap')
+
+    # 2b. Bar chart
+    try:
+        bars = {
+            'data':[
+                {'type':'bar','x':top_feats,'y':[abs(next((i['shap_value'] for i in valid_na if i['feature']==f),0)) for f in top_feats],
+                 'name':'NA Impact'},
+                {'type':'bar','x':top_feats,'y':[abs(next((i['shap_value'] for i in valid_r  if i['feature']==f),0)) for f in top_feats],
+                 'name':'Readmission Impact'}
+            ],
+            'layout':{
+                'title':'Feature Importance (Absolute SHAP)',
+                'barmode':'group','bargap':0.15,'bargroupgap':0.1,
+                'height':450,'margin':{'t':50,'b':150,'l':60,'r':20},
+                'xaxis':{'tickangle':-45,'automargin':True},
+                'plot_bgcolor':plot_bgcolor,'paper_bgcolor':paper_bgcolor,
+                'font':{'family':font_family,'color':font_color},
+                'autosize':True
+            }
+        }
+        visualizations['feature_comparison']=json.dumps(bars, cls=plotly.utils.PlotlyJSONEncoder)
+    except Exception as e:
+        print(f"Error bar chart: {e}")
+        visualizations['feature_comparison']=create_placeholder_plot('Feature Importance Comparison')
+
+    # --- 3. Intervention Impact ---
+    try:
+        interventions=[]
+        mod_set={'Number of Medicines','Cost per Medicine (₹)','Days Medicine Lasts',
+                 'Total Dosage per Day (mg)','Total Pills Given','Medicine Availability (0-1)',
+                 'Took Medicine Day 1 (1=Yes)','Took Medicine Day 2 (1=Yes)',
+                 'Took Medicine Day 3 (1=Yes)'}
+        map_label={
+            'Number of Medicines':'Reduce # Medicines',
+            'Cost per Medicine (₹)':'Reduce Med Cost',
+            'Days Medicine Lasts':'Optimize Refill',
+            'Total Dosage per Day (mg)':'Optimize Dosage',
+            'Total Pills Given':'Reduce Pill Burden',
+            'Medicine Availability (0-1)':'Improve Availability',
+            **{f:f.replace('Took Medicine','Ensure') for f in mod_set if f.startswith('Took Medicine')}
+        }
+        thresh=0.015
+        for f in mod_set:
+            na_v=abs(next((i['shap_value'] for i in valid_na if i['feature']==f),0))
+            r_v =abs(next((i['shap_value'] for i in valid_r  if i['feature']==f),0))
+            if na_v>thresh or r_v>thresh:
+                interventions.append({'intervention':map_label.get(f,f),'na':na_v,'r':r_v})
+        topi=sorted(interventions, key=lambda x:x['na']+x['r'],reverse=True)[:6]
+        if topi:
+            chart={'data':[
+                {'type':'bar','orientation':'h','y':[i['intervention'] for i in topi],
+                 'x':[i['na'] for i in topi],'name':'NA Reduction','text':[f"{i['na']:.3f}" for i in topi],
+                 'textposition':'outside'},
+                {'type':'bar','orientation':'h','y':[i['intervention'] for i in topi],
+                 'x':[i['r'] for i in topi],'name':'R Reduction','text':[f"{i['r']:.3f}" for i in topi],
+                 'textposition':'outside'}
+            ],
+            'layout':{
+                'title':'Top Potential Intervention Impacts',
+                'barmode':'group','height':max(350,50*len(topi)),
+                'margin':{'t':50,'l':200,'b':50,'r':50},
+                'yaxis':{'autorange':'reversed','automargin':True},
+                'plot_bgcolor':plot_bgcolor,'paper_bgcolor':paper_bgcolor,
+                'font':{'family':font_family,'color':font_color},
+                'autosize':True
+            }}
+            visualizations['intervention_impact']=json.dumps(chart, cls=plotly.utils.PlotlyJSONEncoder)
+        else:
+            visualizations['intervention_impact']=create_placeholder_plot(
+                'Potential Intervention Impact',
+                message="No significant interventions identified."
+            )
+    except Exception as e:
+        print(f"Error interventions: {e}")
+        visualizations['intervention_impact']=create_placeholder_plot('Potential Intervention Impact')
+
+    # --- 4. Network Graph ---
+    try:
+        import networkx as nx
+        G=nx.Graph()
+        # Use combined_impact from above
+        N=8
+        topN=sorted(combined_impact, key=lambda f:combined_impact[f], reverse=True)[:N]
+        for f in topN:
+            G.add_node(f, size=combined_impact[f])
+        for i,a in enumerate(topN):
+            for b in topN[i+1:]:
+                w=combined_impact[a]+combined_impact[b]
+                G.add_edge(a,b,weight=w)
+        pos=nx.spring_layout(G,k=0.5,iterations=50,seed=42)
+        ex,ey=[],[]
+        for u,v in G.edges():
+            x0,y0=pos[u]; x1,y1=pos[v]
+            ex+=[x0,x1,None]; ey+=[y0,y1,None]
+        nx_,ny_=[],[]
+        ns=[G.nodes[n]['size']*50 for n in G.nodes()]
+        for n in G.nodes():
+            x,y=pos[n]
+            nx_.append(x); ny_.append(y)
+        net={
+            'data':[
+                {'type':'scatter','x':ex,'y':ey,'mode':'lines','line':{'width':1,'color':'#888'},'hoverinfo':'none'},
+                {'type':'scatter','x':nx_,'y':ny_,'mode':'markers+text',
+                 'marker':{'size':ns,'color':'#1f77b4','opacity':0.8},
+                 'text':list(G.nodes()),'textposition':'top center','hoverinfo':'text'}
+            ],
+            'layout':{
+                'title':'Risk Factor Network',
+                'showlegend':False,
+                'xaxis':{'visible':False},'yaxis':{'visible':False},
+                'plot_bgcolor':paper_bgcolor,'paper_bgcolor':paper_bgcolor,
+                'margin':{'l':20,'r':20,'t':40,'b':20},'autosize':True
+            }
+        }
+        visualizations['network_graph']=json.dumps(net, cls=plotly.utils.PlotlyJSONEncoder)
+    except Exception as e:
+        print(f"Error creating network graph: {e}")
+        visualizations['network_graph']=create_placeholder_plot(
+            'Risk Factor Network',
+            message="Network data unavailable."
+        )
+
+    print("Finished generating additional visualizations.")
+    return visualizations
+
+
+# --- Main Execution ---
+if __name__ == '__main__':
+    print("Starting Flask application...")
+    port = int(os.environ.get("PORT", 5000))
+    # Set debug=False when deploying
+    # Use debug=True for local development ONLY
+    app.run(debug=False, host='0.0.0.0', port=port)