Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,765 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+import plotly.express as px
+from plotly.subplots import make_subplots
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import MinMaxScaler
+from sklearn.linear_model import LogisticRegression
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score, confusion_matrix
+from sklearn.preprocessing import MinMaxScaler
+from sklearn.utils import resample
+import xgboost as xgb  
+import pickle
+import io
+import base64
+from datetime import datetime
+import warnings
+warnings.filterwarnings('ignore')
+
+# Color palette
+COLORS = {
+    'primary': '#14213d',      # Dark blue
+    'secondary': '#fca311',    # Orange
+    'background': '#ffffff',   # White
+    'light_gray': '#e5e5e5',  # Light gray
+    'black': '#000000'         # Black
+}
+
+# Custom CSS
+def apply_custom_css():
+    st.markdown(f"""
+    <style>
+    .main {{
+        background-color: {COLORS['background']};
+    }}
+    
+    /* Force all text to be black */
+    .stApp, .main, .block-container {{
+        color: {COLORS['black']} !important;
+    }}
+    
+    /* Override Streamlit's default text colors */
+    h1, h2, h3, h4, h5, h6 {{
+        color: {COLORS['light_gray']} !important;
+    }}
+    
+  
+    p, div, span {{
+        color: {COLORS['black']} !important;
+    }}
+    
+    /* Input fields and labels */
+    .stTextInput > label, .stSelectbox > label, .stNumberInput > label {{
+        color: {COLORS['black']} !important;
+        font-weight: bold;
+    }}
+    
+    .stTextInput input, .stSelectbox select, .stNumberInput input {{
+        color: {COLORS['light_gray']} !important;
+    }}
+    
+    /* Success/Error messages */
+    .stSuccess, .stError, .stWarning, .stInfo {{
+        color: {COLORS['black']} !important;
+    }}
+    
+    .stSuccess div, .stError div, .stWarning div, .stInfo div {{
+        color: {COLORS['black']} !important;
+    }}
+    
+    /* Buttons */
+    .stButton > button {{
+        background-color: {COLORS['secondary']};
+        color: {COLORS['primary']};
+        border: none;
+        border-radius: 5px;
+        font-weight: bold;
+    }}
+    
+    .stButton > button:hover {{
+        background-color: {COLORS['primary']};
+        color: {COLORS['secondary']};
+    }}
+    
+    /* Metric cards */
+    .metric-card {{
+        background-color: {COLORS['light_gray']};
+        padding: 20px;
+        border-radius: 10px;
+        border-left: 5px solid {COLORS['secondary']};
+        margin: 10px 0;
+        color: {COLORS['black']} !important;
+    }}
+    
+    .metric-card h2, .metric-card h3 {{
+        color: {COLORS['primary']} !important;
+    }}
+    
+    /* Prediction results */
+    .prediction-result {{
+        background-color: {COLORS['primary']};
+        color: {COLORS['background']} !important;
+        padding: 15px;
+        border-radius: 10px;
+        text-align: center;
+        margin: 20px 0;
+    }}
+    
+    .prediction-result h2, .prediction-result h3 {{
+        color: {COLORS['background']} !important;
+    }}
+    
+    /* Header text */
+    .header-text {{
+        color: {COLORS['primary']} !important;
+        font-weight: bold;
+    }}
+    
+    /* Sidebar text */
+    .css-1d391kg, .css-1lcbmhc {{
+        color: {COLORS['light_gray']} !important;
+    }}
+    
+    /* Dataframe text */
+    .dataframe {{
+        color: {COLORS['black']} !important;
+    }}
+    
+    /* Tab labels */
+    .stTabs [data-baseweb="tab-list"] button [data-testid="stMarkdownContainer"] p {{
+        color: {COLORS['light_gray']} !important;
+    }}
+    
+    /* Markdown text */
+    .stMarkdown {{
+        color: {COLORS['light_gray']} !important;
+    }}
+    
+    /* File uploader */
+    .stFileUploader > label {{
+        color: {COLORS['black']} !important;
+    }}
+    
+    /* Multiselect */
+    .stMultiSelect > label {{
+        color: {COLORS['black']} !important;
+    }}
+    
+    /* Slider */
+    .stSlider > label {{
+        color: {COLORS['light_gray']} !important;
+    }}
+    
+    /* Checkbox */
+    .stCheckbox > label {{
+        color: {COLORS['black']} !important;
+    }}
+    </style>
+    """, unsafe_allow_html=True)
+
+# Initialize session state
+def init_session_state():
+    if 'logged_in' not in st.session_state:
+        st.session_state.logged_in = False
+    if 'model_trained' not in st.session_state:
+        st.session_state.model_trained = False
+    if 'model' not in st.session_state:
+        st.session_state.model = None
+    if 'scaler' not in st.session_state:
+        st.session_state.scaler = None
+    if 'data' not in st.session_state:
+        st.session_state.data = None
+    if 'model_results' not in st.session_state:
+        st.session_state.model_results = None
+
+# Login page
+def login_page():
+    st.markdown('<h1 class="header-text">🏦 Sunrise Microfinance Bank</h1>', unsafe_allow_html=True)
+    st.markdown('<h2 class="header-text">Customer Churn Prediction System</h2>', unsafe_allow_html=True)
+    
+    col1, col2, col3 = st.columns([1, 2, 1])
+    
+    with col2:
+        st.markdown("### Admin Login")
+        username = st.text_input("Username", placeholder="Enter admin username")
+        password = st.text_input("Password", type="password", placeholder="Enter password")
+        
+        if st.button("Login", use_container_width=True):
+            # Simple authentication (in production, use proper authentication)
+            if username == "admin" and password == "admin123":
+                st.session_state.logged_in = True
+                st.success("Login successful!")
+            else:
+                st.error("Invalid credentials. Use admin/admin123")
+
+# Simple oversampling function to replace SMOTE
+def simple_oversample(X, y, random_state=42):
+    """Simple oversampling by duplicating minority class samples"""
+    np.random.seed(random_state)
+    
+    # Combine features and target
+    df = pd.concat([X.reset_index(drop=True), y.reset_index(drop=True)], axis=1)
+    
+    # Separate majority and minority classes
+    majority_class = df[df[y.name] == 0]
+    minority_class = df[df[y.name] == 1]
+    
+    # Oversample minority class
+    minority_upsampled = resample(minority_class, 
+                                 replace=True,
+                                 n_samples=len(majority_class),
+                                 random_state=random_state)
+    
+    # Combine majority and upsampled minority
+    df_upsampled = pd.concat([majority_class, minority_upsampled])
+    
+    # Separate features and target
+    X_resampled = df_upsampled.drop(y.name, axis=1)
+    y_resampled = df_upsampled[y.name]
+    
+    return X_resampled, y_resampled
+
+# Data preprocessing function
+def preprocess_data(df):
+    # Drop non-predictive columns
+    if 'CustomerId' in df.columns:
+        df = df.drop(['CustomerId'], axis=1)
+    if 'Surname' in df.columns:
+        df = df.drop(['Surname'], axis=1)
+    
+    # Feature encoding
+    df['Gender'] = df['Gender'].map({'Male': 0, 'Female': 1})
+    df['Account Activity'] = df['Account Activity'].map({'Active': 0, 'Dormant': 1})
+    df['Repayment Timeliness'] = df['Repayment Timeliness'].map({'On-time': 0, 'Late': 1})
+    
+    df['Account Balance Trend'] = df['Account Balance Trend'].map({
+        'Decreasing': 0,
+        'Stable': 1,
+        'Increasing': 2
+    })
+    
+    # Convert binary columns to int
+    binary_columns = ['Use of Savings Products', 'Use of Loan Products', 'Participation in Group Lending']
+    for col in binary_columns:
+        if col in df.columns:
+            df[col] = df[col].astype(int)
+    
+    # One-hot encoding for categorical variables
+    categorical_columns = ['Marital Status', 'Education Level', 'Loan History', 'Use of Digital Banking']
+    for col in categorical_columns:
+        if col in df.columns:
+            df = pd.get_dummies(df, columns=[col], prefix=col.replace(' ', '_'))
+    
+    return df
+
+# Dashboard page
+def dashboard_page():
+    st.markdown('<h1 class="header-text">📊 Super Admin Dashboard</h1>', unsafe_allow_html=True)
+    
+    if st.session_state.data is not None:
+        df = st.session_state.data
+        
+        # Key metrics
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            st.markdown(f"""
+            <div class="metric-card">
+                <h3>Total Customers</h3>
+                <h2>{len(df)}</h2>
+            </div>
+            """, unsafe_allow_html=True)
+        
+        with col2:
+            churn_rate = df['Exited'].mean() * 100 if 'Exited' in df.columns else 0
+            st.markdown(f"""
+            <div class="metric-card">
+                <h3>Churn Rate</h3>
+                <h2>{churn_rate:.1f}%</h2>
+            </div>
+            """, unsafe_allow_html=True)
+        
+        with col3:
+            active_customers = len(df) - df['Exited'].sum() if 'Exited' in df.columns else len(df)
+            st.markdown(f"""
+            <div class="metric-card">
+                <h3>Active Customers</h3>
+                <h2>{active_customers}</h2>
+            </div>
+            """, unsafe_allow_html=True)
+        
+        with col4:
+            avg_age = df['Age'].mean() if 'Age' in df.columns else 0
+            st.markdown(f"""
+            <div class="metric-card">
+                <h3>Average Age</h3>
+                <h2>{avg_age:.1f}</h2>
+            </div>
+            """, unsafe_allow_html=True)
+        
+        # Charts
+        st.markdown("### 📈 Customer Analytics")
+        
+        if 'Exited' in df.columns:
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                # Churn distribution
+                churn_counts = df['Exited'].value_counts()
+                fig = go.Figure(data=[go.Pie(
+                    labels=['Retained', 'Churned'],
+                    values=[churn_counts[0], churn_counts[1]],
+                    marker_colors=[COLORS['secondary'], COLORS['primary']]
+                )])
+                fig.update_layout(title="Customer Retention vs Churn", title_x=0.5)
+                st.plotly_chart(fig, use_container_width=True)
+            
+            with col2:
+                # Age distribution by churn
+                fig = px.histogram(df, x='Age', color='Exited', nbins=20,
+                                 title="Age Distribution by Churn Status",
+                                 color_discrete_map={0: COLORS['secondary'], 1: COLORS['primary']})
+                st.plotly_chart(fig, use_container_width=True)
+    
+    else:
+        st.info("Please upload data first to see dashboard metrics.")
+
+# Upload data page
+def upload_data_page():
+    st.markdown('<h1 class="header-text">📁 Upload Customer Data</h1>', unsafe_allow_html=True)
+    
+    uploaded_file = st.file_uploader(
+        "Choose a CSV file",
+        type=['csv'],
+        help="Upload your customer dataset in CSV format"
+    )
+    
+    if uploaded_file is not None:
+        try:
+            df = pd.read_csv(uploaded_file)
+            st.success(f"Data uploaded successfully! {len(df)} records loaded.")
+            
+            # Display data info
+            st.markdown("### Data Preview")
+            st.dataframe(df.head(10))
+            
+            st.markdown("### Data Summary")
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.markdown("**Dataset Shape:**")
+                st.write(f"Rows: {df.shape[0]}")
+                st.write(f"Columns: {df.shape[1]}")
+            
+            with col2:
+                st.markdown("**Missing Values:**")
+                missing_values = df.isnull().sum().sum()
+                st.write(f"Total: {missing_values}")
+            
+            # Store data in session state
+            st.session_state.data = df
+            
+            if st.button("Process Data", use_container_width=True):
+                with st.spinner("Processing data..."):
+                    processed_df = preprocess_data(df.copy())
+                    st.session_state.processed_data = processed_df
+                    st.success("Data processed successfully!")
+                    st.markdown("### Processed Data Preview")
+                    st.dataframe(processed_df.head())
+                    
+        except Exception as e:
+            st.error(f"Error loading data: {str(e)}")
+    
+    # Sample data option
+    st.markdown("### Or Use Sample Data")
+    if st.button("Load Sample Data"):
+        # Create sample data based on your description
+        np.random.seed(42)
+        n_samples = 1000
+        
+        sample_data = {
+            'CustomerId': [f'SMB{15565700 + i + 1}' for i in range(n_samples)],
+            'Surname': ['Abdullahi', 'Bello', 'Adesina', 'Sule', 'Nwachukwu'] * (n_samples // 5),
+            'Age': np.random.randint(18, 92, n_samples),
+            'Gender': np.random.choice(['Male', 'Female'], n_samples),
+            'Marital Status': np.random.choice(['Single', 'Married', 'Divorced'], n_samples),
+            'Education Level': np.random.choice(['None', 'Primary', 'Secondary', 'Tertiary'], n_samples),
+            'Account Balance Trend': np.random.choice(['Decreasing', 'Stable', 'Increasing'], n_samples),
+            'Loan History': np.random.choice(['Active', 'Cleared', 'Defaulted'], n_samples),
+            'Frequency of Deposits/Withdrawals': np.random.randint(0, 15, n_samples),
+            'Average Transaction Value': np.random.uniform(1000, 50000, n_samples),
+            'Account Activity': np.random.choice(['Active', 'Dormant'], n_samples),
+            'Use of Savings Products': np.random.choice([0, 1], n_samples),
+            'Use of Loan Products': np.random.choice([0, 1], n_samples),
+            'Use of Digital Banking': np.random.choice(['USSD', 'App', 'Both', 'None'], n_samples),
+            'Participation in Group Lending': np.random.choice([0, 1], n_samples),
+            'Tenure': np.random.randint(0, 10, n_samples),
+            'Number of Complaints Logged': np.random.randint(0, 5, n_samples),
+            'Response Time to Complaints': np.random.randint(0, 15, n_samples),
+            'Customer Support Interactions': np.random.randint(0, 10, n_samples),
+            'Repayment Timeliness': np.random.choice(['On-time', 'Late'], n_samples),
+            'Overdue Loan Frequency': np.random.randint(0, 5, n_samples),
+            'Penalties Paid': np.random.uniform(0, 10000, n_samples),
+            'Exited': np.random.choice([0, 1], n_samples, p=[0.8, 0.2])
+        }
+        
+        df = pd.DataFrame(sample_data)
+        st.session_state.data = df
+        st.success("Sample data loaded successfully!")
+        st.dataframe(df.head())
+
+# Model training page
+def model_training_page():
+    st.markdown('<h1 class="header-text">🤖 Model Training</h1>', unsafe_allow_html=True)
+    
+    if st.session_state.data is None:
+        st.warning("Please upload data first.")
+        return
+    
+    df = st.session_state.data.copy()
+    
+    st.markdown("### Training Configuration")
+    
+    col1, col2 = st.columns(2)
+    with col1:
+        test_size = st.slider("Test Size", 0.1, 0.5, 0.3, 0.05)
+        use_oversampling = st.checkbox("Use Oversampling for Imbalanced Data", value=True)
+
+    with col2:
+        random_state = st.number_input("Random State", value=42)
+    
+    selected_features = st.multiselect(
+        "Select Features for Training",
+        ['Age', 'Gender', 'Tenure', 'Frequency of Deposits/Withdrawals', 
+         'Repayment Timeliness', 'Account Activity', 'Account Balance Trend'],
+        default=['Age', 'Gender', 'Tenure', 'Frequency of Deposits/Withdrawals', 
+                'Repayment Timeliness', 'Account Activity', 'Account Balance Trend']
+    )
+    
+    if st.button("Train Models", use_container_width=True):
+        if not selected_features:
+            st.error("Please select at least one feature.")
+            return
+            
+        with st.spinner("Training models..."):
+            # Preprocess data
+            processed_df = preprocess_data(df)
+            
+            # Prepare features and target
+            available_features = [f for f in selected_features if f in processed_df.columns]
+            X = processed_df[available_features]
+            y = processed_df['Exited']
+            
+            # Handle class imbalance with SMOTE
+            if use_oversampling:
+                X_resampled, y_resampled = simple_oversample(X, y, random_state=random_state)
+            else:
+                X_resampled, y_resampled = X, y
+            # Feature scaling
+            scaler = MinMaxScaler()
+            X_scaled = scaler.fit_transform(X_resampled)
+            X_scaled = pd.DataFrame(X_scaled, columns=X.columns)
+            
+            # Split data
+            X_train, X_test, y_train, y_test = train_test_split(
+                X_scaled, y_resampled, test_size=test_size, random_state=random_state
+            )
+            
+            # Train models
+            models = {
+                'Logistic Regression': LogisticRegression(random_state=random_state),
+                'Random Forest': RandomForestClassifier(random_state=random_state, n_estimators=100),
+                'XGBoost': xgb.XGBClassifier(random_state=random_state, use_label_encoder=False, eval_metric='logloss')
+            }
+            
+            results = {}
+            trained_models = {}
+            
+            for name, model in models.items():
+                model.fit(X_train, y_train)
+                y_pred = model.predict(X_test)
+                y_pred_proba = model.predict_proba(X_test)[:, 1]
+                
+                results[name] = {
+                    'Accuracy': accuracy_score(y_test, y_pred),
+                    'Precision': precision_score(y_test, y_pred),
+                    'Recall': recall_score(y_test, y_pred),
+                    'F1-Score': f1_score(y_test, y_pred),
+                    'ROC-AUC': roc_auc_score(y_test, y_pred_proba)
+                }
+                trained_models[name] = model
+            
+            # Select best model
+            best_model_name = max(results, key=lambda x: results[x]['F1-Score'])
+            best_model = trained_models[best_model_name]
+            
+            # Store in session state
+            st.session_state.model = best_model
+            st.session_state.scaler = scaler
+            st.session_state.model_results = results
+            st.session_state.best_model_name = best_model_name
+            st.session_state.feature_names = X.columns.tolist()
+            st.session_state.model_trained = True
+            st.session_state.X_test = X_test
+            st.session_state.y_test = y_test
+            
+            st.success(f"Models trained successfully! Best model: {best_model_name}")
+            
+            # Display results
+            st.markdown("### Model Performance")
+            results_df = pd.DataFrame(results).T
+            st.dataframe(results_df.round(4))
+            
+            # Feature importance
+            if best_model_name in ['Random Forest', 'XGBoost']:
+                st.markdown("### Feature Importance")
+                importance_df = pd.DataFrame({
+                    'Feature': X.columns,
+                    'Importance': best_model.feature_importances_
+                }).sort_values('Importance', ascending=False)
+                
+                fig = px.bar(importance_df, x='Importance', y='Feature', 
+                           orientation='h', title="Feature Importance",
+                           color_discrete_sequence=[COLORS['secondary']])
+                st.plotly_chart(fig, use_container_width=True)
+
+# Prediction page
+def prediction_page():
+    st.markdown('<h1 class="header-text">🔮 Customer Churn Prediction</h1>', unsafe_allow_html=True)
+    
+    if not st.session_state.model_trained:
+        st.warning("Please train a model first.")
+        return
+    
+    tab1, tab2 = st.tabs(["Single Prediction", "Bulk Prediction"])
+    
+    with tab1:
+        st.markdown("### Single Customer Prediction")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            age = st.number_input("Age", 18, 100, 35)
+            gender = st.selectbox("Gender", ["Male", "Female"])
+            tenure = st.number_input("Tenure (years)", 0, 10, 2)
+            freq_deposits = st.number_input("Frequency of Deposits/Withdrawals", 0, 14, 5)
+        
+        with col2:
+            repayment = st.selectbox("Repayment Timeliness", ["On-time", "Late"])
+            account_activity = st.selectbox("Account Activity", ["Active", "Dormant"])
+            balance_trend = st.selectbox("Account Balance Trend", ["Decreasing", "Stable", "Increasing"])
+        
+        if st.button("Predict Churn", use_container_width=True):
+            # Prepare input data
+            input_data = pd.DataFrame({
+                'Age': [age / 100],  # Normalized
+                'Gender': [1 if gender == "Female" else 0],
+                'Tenure': [tenure / 10],  # Normalized
+                'Frequency of Deposits/Withdrawals': [freq_deposits / 14],  # Normalized
+                'Repayment Timeliness': [1 if repayment == "Late" else 0],
+                'Account Activity': [1 if account_activity == "Dormant" else 0],
+                'Account Balance Trend': [0 if balance_trend == "Decreasing" else 1 if balance_trend == "Stable" else 2]
+            })
+            
+            # Make prediction
+            prediction = st.session_state.model.predict(input_data)[0]
+            probability = st.session_state.model.predict_proba(input_data)[0]
+            
+            # Display result
+            if prediction == 1:
+                st.markdown(f"""
+                <div class="prediction-result" style="background-color: {COLORS['primary']};">
+                    <h2>⚠️ HIGH CHURN RISK</h2>
+                    <h3>Probability: {probability[1]:.1%}</h3>
+                </div>
+                """, unsafe_allow_html=True)
+            else:
+                st.markdown(f"""
+                <div class="prediction-result" style="background-color: {COLORS['secondary']};">
+                    <h2>✅ LOW CHURN RISK</h2>
+                    <h3>Probability: {probability[0]:.1%}</h3>
+                </div>
+                """, unsafe_allow_html=True)
+            
+            # Key factors
+            st.markdown("### Key Risk Factors")
+            risk_factors = []
+            if age < 30 or age > 70:
+                risk_factors.append("Age group has higher churn tendency")
+            if account_activity == "Dormant":
+                risk_factors.append("Dormant account increases churn risk")
+            if repayment == "Late":
+                risk_factors.append("Late repayments indicate financial stress")
+            if freq_deposits < 3:
+                risk_factors.append("Low transaction frequency")
+            if tenure < 2:
+                risk_factors.append("Short tenure with bank")
+            
+            if risk_factors:
+                for factor in risk_factors:
+                    st.write(f"• {factor}")
+            else:
+                st.write("• Customer profile shows good retention indicators")
+    
+    with tab2:
+        st.markdown("### Bulk Prediction")
+        
+        uploaded_file = st.file_uploader(
+            "Upload CSV file for bulk prediction",
+            type=['csv'],
+            help="Upload a CSV file with customer data"
+        )
+        
+        if uploaded_file is not None:
+            try:
+                df = pd.read_csv(uploaded_file)
+                st.write(f"Loaded {len(df)} records")
+                
+                if st.button("Run Bulk Prediction"):
+                    # Process and predict
+                    processed_df = preprocess_data(df.copy())
+                    
+                    # Ensure all required features are present
+                    required_features = st.session_state.feature_names
+                    available_features = [f for f in required_features if f in processed_df.columns]
+                    
+                    if len(available_features) == len(required_features):
+                        X = processed_df[available_features]
+                        X_scaled = st.session_state.scaler.transform(X)
+                        
+                        predictions = st.session_state.model.predict(X_scaled)
+                        probabilities = st.session_state.model.predict_proba(X_scaled)[:, 1]
+                        
+                        # Add results to dataframe
+                        results_df = df.copy()
+                        results_df['Churn_Prediction'] = ['High Risk' if p == 1 else 'Low Risk' for p in predictions]
+                        results_df['Churn_Probability'] = probabilities
+                        
+                        st.markdown("### Prediction Results")
+                        st.dataframe(results_df)
+                        
+                        # Summary
+                        high_risk_count = sum(predictions)
+                        st.markdown(f"**Summary:** {high_risk_count} out of {len(df)} customers are at high risk of churn ({high_risk_count/len(df)*100:.1f}%)")
+                        
+                        # Download results
+                        csv = results_df.to_csv(index=False)
+                        st.download_button(
+                            "Download Results",
+                            csv,
+                            "churn_predictions.csv",
+                            "text/csv"
+                        )
+                    else:
+                        st.error("Missing required features in uploaded data")
+                        
+            except Exception as e:
+                st.error(f"Error processing file: {str(e)}")
+
+# Reports page
+def reports_page():
+    st.markdown('<h1 class="header-text">📊 Model Reports</h1>', unsafe_allow_html=True)
+    
+    if not st.session_state.model_trained:
+        st.warning("Please train a model first to view reports.")
+        return
+    
+    # Model performance summary
+    st.markdown("### Model Performance Summary")
+    results_df = pd.DataFrame(st.session_state.model_results).T
+    st.dataframe(results_df.round(4))
+    
+    # Best model info
+    st.info(f"Best Model: {st.session_state.best_model_name}")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        # Feature importance
+        if st.session_state.best_model_name in ['Random Forest', 'XGBoost']:
+            st.markdown("### Feature Importance")
+            importance_df = pd.DataFrame({
+                'Feature': st.session_state.feature_names,
+                'Importance': st.session_state.model.feature_importances_
+            }).sort_values('Importance', ascending=False)
+            
+            fig = px.bar(importance_df, x='Importance', y='Feature', 
+                       orientation='h',
+                       color_discrete_sequence=[COLORS['secondary']])
+            fig.update_layout(height=400)
+            st.plotly_chart(fig, use_container_width=True)
+    
+    with col2:
+        # Confusion matrix
+        st.markdown("### Confusion Matrix")
+        if hasattr(st.session_state, 'X_test') and hasattr(st.session_state, 'y_test'):
+            y_pred = st.session_state.model.predict(st.session_state.X_test)
+            cm = confusion_matrix(st.session_state.y_test, y_pred)
+            
+            fig = px.imshow(cm, 
+                          text_auto=True, 
+                          aspect="auto",
+                          color_continuous_scale='Blues',
+                          labels=dict(x="Predicted", y="Actual"))
+            fig.update_layout(height=400)
+            st.plotly_chart(fig, use_container_width=True)
+    
+    # Recommendations
+    st.markdown("### Business Recommendations")
+    recommendations = [
+        "Focus retention efforts on customers with short tenure and low transaction frequency",
+        "Implement proactive engagement for dormant accounts",
+        "Develop targeted programs for high-risk age groups",
+        "Improve digital banking adoption to increase engagement",
+        "Monitor and address late payment patterns early",
+        "Create loyalty programs for long-term customers"
+    ]
+    
+    for i, rec in enumerate(recommendations, 1):
+        st.write(f"{i}. {rec}")
+
+# Main app
+def main():
+    st.set_page_config(
+        page_title="Customer Churn Prediction",
+        page_icon="🏦",
+        layout="wide",
+        initial_sidebar_state="expanded"
+    )
+    
+    apply_custom_css()
+    init_session_state()
+    
+    if not st.session_state.logged_in:
+        login_page()
+        return
+    
+    # Sidebar navigation
+    st.sidebar.markdown("### Navigation")
+    pages = {
+        "🏠 Dashboard": dashboard_page,
+        "📁 Upload Data": upload_data_page,
+        "🤖 Train Model": model_training_page,
+        "🔮 Predictions": prediction_page,
+        "📊 Reports": reports_page
+    }
+    
+    selected_page = st.sidebar.selectbox("Choose a page", list(pages.keys()))
+    
+    # Logout button
+    if st.sidebar.button("Logout"):
+        st.session_state.logged_in = False
+    
+    # Display selected page
+    pages[selected_page]()
+    
+    # Footer
+    st.sidebar.markdown("---")
+    st.sidebar.markdown("**Sunrise Microfinance Bank**")
+    st.sidebar.markdown("Customer Churn Prediction System")
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+if __name__ == "__main__":
+    main()