Streamlit_app_European_bank.py

import streamlit as st
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import joblib
import os


st.set_page_config(page_title="Customer Churn Dashboard", layout="wide")

#Loading the model
#model=joblib.load("churn_model.pkl'")
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
model_path = os.path.join(BASE_DIR, "churn_model.pkl")

model = joblib.load(model_path)

#Load dataset at once
df=pd.read_csv("European_Bank.csv")

# ---------------- DASHBOARD FILTERS ----------------
st.sidebar.header("📌 Course Configuration")

selected_geo = st.sidebar.selectbox(
    "Select Geography",
    ["All"] + list(df["Geography"].unique())
)

age_filter = st.sidebar.slider(
    "Select Age Range",
    int(df["Age"].min()),
    int(df["Age"].max()),
    (18, 60)
)

active_only = st.sidebar.checkbox("Active Members Only")

product_filter = st.sidebar.slider(
    "Number of Products",
    int(df["NumOfProducts"].min()),
    int(df["NumOfProducts"].max()),
    (1,4)
)

balance_filter = st.sidebar.slider(
    "Balance Range",
    int(df["Balance"].min()),
    int(df["Balance"].max()),
    (0,200000)
)

salary_filter = st.sidebar.slider(
    "Salary Range",
    int(df["EstimatedSalary"].min()),
    int(df["EstimatedSalary"].max()),
    (0,200000)
)

filtered_df = df.copy()

if selected_geo != "All":
    filtered_df = filtered_df[filtered_df["Geography"] == selected_geo]

filtered_df = filtered_df[
    (filtered_df["Age"] >= age_filter[0]) &
    (filtered_df["Age"] <= age_filter[1])
]

if active_only:
    filtered_df = filtered_df[filtered_df["IsActiveMember"] == 1]

filtered_df = filtered_df[
    (filtered_df["NumOfProducts"] >= product_filter[0]) &
    (filtered_df["NumOfProducts"] <= product_filter[1])
]

filtered_df = filtered_df[
    (filtered_df["Balance"] >= balance_filter[0]) &
    (filtered_df["Balance"] <= balance_filter[1])
]

filtered_df = filtered_df[
    (filtered_df["EstimatedSalary"] >= salary_filter[0]) &
    (filtered_df["EstimatedSalary"] <= salary_filter[1])
]

#Page config
#st.set_page_config(page_title="Customer Churn Dashboard", layout="wide")
col1,col2,col3=st.columns([1,3,1])
with col1:
    st.image("Logo_ecb.png",width=200)
with col2:
    st.title("   🏦 Customer Engagement & Product Utilization Analytics   ")
    st.caption("Customer churn prediction,retention analytics using XGBoost model and provides predictive insights to help banks reduce customer atttrition.")
with col3:
    st.image("Logo_unified.png",width=180)

# ===================================
# 📊 KEY PERFORMANCE INDICATORS (PROJECT BASED)
# ===================================

# ===== KPI CALCULATIONS =====

total_customers = len(filtered_df)

churn_rate = filtered_df["Exited"].mean() * 100

engagement_retention_ratio = (
    filtered_df[filtered_df["IsActiveMember"] == 1].shape[0]
    / total_customers
) * 100

product_depth_index = filtered_df["NumOfProducts"].mean()

high_balance_disengagement_rate = (
    filtered_df[filtered_df["Balance"] > 100000]["Exited"].mean()
) * 100

credit_card_stickiness = (
    filtered_df[filtered_df["HasCrCard"] == 1]["Exited"].mean()
) * 100

relationship_strength_index = (
    (engagement_retention_ratio / 100)
    * product_depth_index
    * (1 - churn_rate / 100)
)

st.subheader(" 📊 Key Performance Indicators")

#left, center, right = st.columns([1, 5, 1])

#with center:
col1, col2, col3, col4, col5, col6 = st.columns(6)

col1.metric("Engagement", f"{engagement_retention_ratio:.1f}%")
col2.metric("Product Depth", f"{product_depth_index:.2f}")
col3.metric("High Balance Risk", f"{high_balance_disengagement_rate:.1f}%")
col4.metric("Credit Card Stickiness", f"{credit_card_stickiness:.1f}%")
col5.metric("Relationship Index", f"{relationship_strength_index:.2f}")
col6.metric("Churn Rate", f"{churn_rate:.1f}%")

st.divider()

#st.divider()

#Sidebar
page = st.sidebar.radio(
    "Select Module",
    ["📊 Overview",
     "📦 Product Analysis",
     "💰 High Value Risk",
     "📈 Retention Score",
     "🤖 Churn Prediction",
     "🧠 Model Insights"]
)

# OVERVIEW PAGE
if page == "📊 Overview":

    #st.header("📊 Key Performance Indicators (KPIs)")

    #kpi_data = pd.DataFrame({
    #    "KPI Name": [
    #        "Engagement Retention Ratio",
    #        "Product Depth Index",
    #        "High-Balance Disengagement Rate",
    #        "Credit Card Stickiness Score",
    #        "Relationship Strength Index"
    #    ],
    #    "Description": [
    #        "Active vs inactive churn comparison",
    #        "Products used vs loyalty",
    #        "Premium churn risk",
   #         "Card ownership retention impact",
   #         "Combined engagement & product score"
    #    ]
    #})

    #st.table(kpi_data)
    #st.divider()

    #pie chart
    st.subheader("Customer Churn Distribution")
    churn_counts=filtered_df["Exited"].value_counts()
    left,center,right=st.columns([1.5,2,1.5])
    with center:
        fig, ax =plt.subplots(figsize=(5,4))
        colors=sns.color_palette("Set2")
        wedges,texts,autotexts=ax.pie(
            churn_counts,
            labels=["Active","Churned"],
            autopct=lambda p:f"{p:.1f}%",
            startangle=90,
            colors=colors,
            textprops={'fontsize':15} , #label size
            wedgeprops={"edgecolor":"white"}
        )
        #percentages font size
        for autotext in autotexts:
            autotext.set_fontsize(15) 
    
        ax.set_title("Churn vs Active Customers",fontsize=15)
        st.pyplot(fig)

        st.divider()

    st.subheader(" Customer Churn Patterns by Geography and Product Usage")
    

    col1, col2 = st.columns(2)

# -------- Geography Churn --------
    with col1:
        geo_churn = filtered_df.groupby("Geography")["Exited"].mean() * 100

        fig2, ax2 = plt.subplots(figsize=(6,3))
        sns.barplot(
            x=geo_churn.index,
            y=geo_churn.values,
            palette="viridis",
            ax=ax2
        )

        ax2.set_title("Churn Rate by Geography", fontsize=10)
        ax2.set_ylabel("%")
        ax2.tick_params(labelsize=8)

        st.pyplot(fig2)


# -------- Product Churn --------
    with col2:
        product_churn = filtered_df.groupby("NumOfProducts")["Exited"].mean() * 100

        fig3, ax3 = plt.subplots(figsize=(6,3))
        sns.barplot(
            x=product_churn.index,
            y=product_churn.values,
            palette="coolwarm",
            ax=ax3
        )

        ax3.set_title("Churn by Products", fontsize=10)
        ax3.set_ylabel("%")
        ax3.tick_params(labelsize=8)

        st.pyplot(fig3)

    

#KPI-2:Product Utilization Impact Analysis
elif page == "📦 Product Analysis":

    st.header("📦 Product Utilization Impact Analysis")

    # Churn by number of products
    #churn_by_products = filtered_df.groupby("NumOfProducts")["Exited"].mean()

    st.subheader("Churn Rate by Number of Products")
    #'''st.line_chart(churn_by_products)

    #st.markdown("---")

    # Average balance by product count
    #avg_balance = filtered_df.groupby("NumOfProducts")["Balance"].mean()

    #st.subheader("Average Balance by Product Count")
    #st.bar_chart(avg_balance)'''

    

    churn_by_products = (
        filtered_df.groupby("NumOfProducts")["Exited"].mean().reset_index()
    )

    left1,center1,right1=st.columns([1,2,1])
    with center1:

        fig1, ax1 = plt.subplots(figsize=(6,3))

        sns.barplot(
            data=churn_by_products,
            x="NumOfProducts",
            y="Exited",
            palette="Blues"
        )

        ax1.set_ylabel("Churn Rate")
        ax1.set_xlabel("Number of Products")
        ax1.set_title("Product Usage vs Churn")

        st.pyplot(fig1)
    st.divider()
   

    avg_balance = (
        filtered_df.groupby("NumOfProducts")["Balance"].mean().reset_index()
        )
    
    st.subheader("Average Balance by Product Count")

    left2,center2,right2=st.columns([1,2,1])
    with center2:

        fig2, ax2 = plt.subplots(figsize=(6,3))

        sns.barplot(
            data=avg_balance,
            x="NumOfProducts",
            y="Balance",
            palette="Greens",
        )

        ax2.set_title("Balance Distribution by Product Count",fontsize=10)
        ax2.set_ylabel("Churn Rate")
        ax2.set_xlabel("Num of Products")
        ax2.tick_params(labelsize=8)

        st.pyplot(fig2)




#KPI-3: High-value Disengaged Customer Detector
elif page == "💰 High Value Risk":

    st.header(" High-Value Disengaged Customers")

    # Define threshold
    balance_threshold = st.slider("Select Minimum Balance", 0, 300000, 100000)

    # High value customers
    high_value = filtered_df[filtered_df["Balance"] > balance_threshold]

    # Among them, churned customers
    high_risk = high_value[high_value["Exited"] == 1]

    total_high_value = len(high_value)
    total_high_risk = len(high_risk)
    risk_percentage=(total_high_risk/total_high_value)*100 if total_high_value >0 else 0
    col1, col2,col3 = st.columns(3)

    col1.metric("💰 High Value Customers", total_high_value)
    col2.metric("⚠ High Value At Risk", total_high_risk)
    col3.metric("📊 Risk Percentage",f"{risk_percentage:.1f}%")

    st.markdown("---")

    if total_high_risk > 0:
        st.error("🔴 These premium customers are at churn risk!")
        st.dataframe(high_risk.head(20))
    else:
        st.success("🟢 No high-value churn risk detected.")

    
#KPI-4:Retention Strength Scoring Panel
elif page == "📈 Retention Score":

    st.header("📈 Retention Strength Scoring Panel")

    # ---- Create Retention Score ----
    filtered_df["RetentionScore"] = (
        filtered_df["IsActiveMember"] * 30 +
        filtered_df["NumOfProducts"] * 20 +
        filtered_df["HasCrCard"] * 10 +
        filtered_df["Tenure"] * 2
    )

    # Scale to 0-100
    filtered_df["RetentionScore"] = (filtered_df["RetentionScore"] / filtered_df["RetentionScore"].max()) * 100

    avg_score = filtered_df["RetentionScore"].mean()
    high_retention = len(filtered_df[filtered_df["RetentionScore"] > 60])
    low_retention = len(filtered_df[filtered_df["RetentionScore"] < 30])

    # ---- KPI Cards ----
    col1, col2, col3 = st.columns(3)

    col1.metric("⭐ Average Retention Score", f"{avg_score:.2f}")
    col2.metric("💚 High Retention Customers", high_retention)
    col3.metric("🔴 Low Retention Customers", low_retention)

    st.markdown("---")

    # ---- Color Based Status ----
    if avg_score > 70:
        st.success("🟢 Strong Customer Loyalty Overall")
    elif avg_score > 40:
        st.warning("🟡 Moderate Retention Strength")
    else:
        st.error("🔴 Weak Retention – Attention Needed")

    st.markdown("---")

    # ---- Histogram Chart ----
    st.subheader("📊 Retention Score Distribution")

    #fig, ax = plt.subplots(figsize=(8,4))
    #sns.histplot(data=filtered_df,x="RetentionScore",bins=20,kde=True,color="#1ABC9C",alpha=0.8)
    #ax.set_hist(filtered_df["RetentionScore"], bins=20)
    #ax.set_xlabel("Retention Score")
    #ax.set_ylabel("Number of Customers")
    #ax.set_title("Retention Score Distribution")
    #st.pyplot(fig)'''


    fig, ax = plt.subplots(figsize=(3.5,2.5))

    sns.set_style("whitegrid")

    sns.histplot(
        data=filtered_df,
        x="RetentionScore",
        hue="Exited",
        bins=15,
        kde=True,
        palette=["#4CAF50","#E53935"],
        alpha=0.6,
        multiple="layer",
        edgecolor="white",
        ax=ax
    )
    #remove default legend
    ax.legend_.remove()

    #add custom legend
    from matplotlib.patches import Patch
    legend_elements=[Patch(facecolor="#4CAF50",label="Retained"),
                     Patch(facecolor="#E53935",label="Churned")
                     ]
    
    ax.legend(
        handles=legend_elements,
        fontsize=7,
        loc="upper right"
    )

    #ax.set_title("Retention Score vs Churn",fontsize=8)
    ax.set_xlabel("Retention Score",fontsize=8)
    ax.set_ylabel("Number of Customers",fontsize=8)
    ax.tick_params(labelsize=7)

   
    left,center,right=st.columns([1,2,1])
    with center:
        st.pyplot(fig)





## Model insights heatmap
elif page == "🧠 Model Insights":

    st.header("🧠 Model Performance & Feature Importance")

    from sklearn.model_selection import train_test_split
    from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
    import seaborn as sns
    import matplotlib.pyplot as plt

    # -------- Prepare Data --------
    X = pd.get_dummies(df.drop("Exited", axis=1), drop_first=True)

    X = X[[
        "CreditScore", "Age", "Tenure", "Balance",
        "NumOfProducts", "HasCrCard", "IsActiveMember",
        "EstimatedSalary", "Geography_Germany",
        "Geography_Spain", "Gender_Male"
    ]]

    y = df["Exited"]

    # -------- Train-Test Split (IMPORTANT for correct accuracy) --------
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=42
    )

    # -------- Model Prediction --------
    y_pred = model.predict(X_test)

    accuracy = accuracy_score(y_test, y_pred)

    st.metric("🎯 Model Accuracy (Test Data)", f"{accuracy*100:.2f}%")

    st.markdown("---")

    # -------- Confusion Matrix --------
    st.subheader("Confusion Matrix")

    cm = confusion_matrix(y_test, y_pred)
    #create small centered layout
    left,center,right=st.columns([1,2,1])
    with center:

        fig_cm, ax_cm = plt.subplots(figsize=(4,3))
        sns.heatmap(
            cm, 
            annot=True, 
            fmt="d",
            cmap="Blues",
            ax=ax_cm,
            annot_kws={"fontsize":8})

        ax_cm.set_xlabel("Predicted",fontsize=9)
        ax_cm.set_ylabel("Actual",fontsize=9)
        ax_cm.set_title("Confusion Matrix",fontsize=8)
        ax_cm.tick_params(labelsize=7)
        plt.tight_layout()

        st.pyplot(fig_cm)

    st.markdown("---")

    # -------- Feature Importance --------
    st.subheader("Top Features Driving Churn")
    
    #sort importance
    importance = model.feature_importances_

    feature_names = [
        "CreditScore", "Age", "Tenure", "Balance",
        "NumOfProducts", "HasCrCard", "IsActiveMember",
        "EstimatedSalary", "Geography_Germany",
        "Geography_Spain", "Gender_Male"
    ]

    importance_df = pd.DataFrame({
        "Feature": feature_names,
        "Importance": importance
    }).sort_values(by="Importance", ascending=False)

    #center layout
    left,center,right=st.columns([1,2,1])
    with center:

        fig_imp, ax_imp = plt.subplots(figsize=(5,4))

        sns.barplot(
            x="Importance",
            y="Feature",
            data=importance_df,
            palette="viridis"
        )

        ax_imp.set_title("Feature Importance (XGBoost)",fontsize=9)
        ax_imp.tick_params(labelsize=8)
        plt.tight_layout()
        st.pyplot(fig_imp)

    st.markdown("---")

    st.dataframe(importance_df, use_container_width=True)

    st.markdown("---")
    st.subheader("🔍 Key Insights from Customer Data")
    st.success("""
    - Customers with higher balances but inactive accounts show increased churn probability.
    - Customers owning only one banking product are more likely to churn.
    - Active members demonstrate significantly better retention rates.
    - Customer age and account balance strongly influence churn behavior.
    """)

    st.markdown("---")
    st.subheader("📢 Business Recommendations")
    st.info("""
    •  Implement targeted retention campaigns for high-value inactive customers.

    •  Encourage cross-selling of banking products to improve customer engagement.

    •  Strengthen loyalty programs for long-term customers.

    •  Provide personalized financial offers based on customer profile and behavior.
    """)



#adding user inputs
if page == "🤖 Churn Prediction":
    st.header("Enter Customer Details")

    credit_score = st.number_input("Credit Score", 300, 900, 650)
    age = st.number_input("Age", 18, 100, 35)
    tenure = st.number_input("Tenure (Years)", 0, 20, 5)
    balance = st.number_input("Balance", 0.0, 300000.0, 50000.0)
    num_products = st.selectbox("Number of Products", [1,2,3,4])
    has_card = st.selectbox("Has Credit Card", [0,1])
    is_active = st.selectbox("Is Active Member", [0,1])
    salary = st.number_input("Estimated Salary", 0.0, 200000.0, 50000.0)

    geography = st.selectbox("Geography", ["France", "Germany", "Spain"])
    gender = st.selectbox("Gender", ["Female", "Male"])

#converting categorical to model format

    geo_germany = 1 if geography == "Germany" else 0
    geo_spain = 1 if geography == "Spain" else 0
    gender_male = 1 if gender == "Male" else 0

#create input DataFrame

#year = 2025
#input_data = np.array([[year,credit_score, age, tenure, balance,
#                        num_products, has_card, is_active,
#                        salary, geo_germany, geo_spain,
#                       gender_male]])


    #prediction button

    if st.button("Predict Churn"):

        input_df=pd.DataFrame({
                           "CreditScore":[credit_score],
                           "Age":[age],
                           "Tenure":[tenure],
                           "Balance":[balance],
                           "NumOfProducts":[num_products],
                           "HasCrCard":[has_card],
                           "IsActiveMember":[is_active],
                           "EstimatedSalary":[salary],
                           "Geography_Germany":[geo_germany],
                           "Geography_Spain":[geo_spain],
                           "Gender_Male":[gender_male]
                           })

        prediction = model.predict(input_df)
        probability = model.predict_proba(input_df)[0][1]

        st.subheader("Prediction Result")
        st.metric(label="Churn Probability",
                  value=f"{probability*100:.2f}%",
                  delta=f"{(probability-0.5)*100:.2f}% vs baseline"
                  )


        if probability >= 0.7:
           st.error("🔴 High Risk of Churn")
        elif probability >= 0.4:
           st.warning("🟠 Medium Risk of Churn")
        else:
           st.success("🟢 Low Risk of Churn")

st.markdown("---")
st.caption("Developed by Jayanthi Varri")