┌─────────────────────────────────────────────────────────────────────────────┐
│                    DATA SOURCES FOR PERSONALISATION                       │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    DEMOGRAPHIC DATA                                 │   │
│  │  Age, gender, income, location, occupation, education              │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    TRANSACTIONAL DATA                               │   │
│  │  Transaction history, spending patterns, payment behaviour          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    BEHAVIOURAL DATA                                 │   │
│  │  Website/app usage, clickstream, session duration, feature usage    │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    INTERACTION DATA                                 │   │
│  │  Customer service interactions, chatbot conversations, surveys      │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    EXTERNAL DATA                                    │   │
│  │  Credit bureau, social media, public records, third-party data      │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    REAL-TIME DATA                                   │   │
│  │  Location, device, time, context, session activity                  │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    RECOMMENDATION SYSTEM ARCHITECTURE                     │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    DATA LAYER                                       │   │
│  │  Customer data, product data, transaction data, behavioural data    │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    FEATURE ENGINEERING                              │   │
│  │  Customer features, product features, historical interactions       │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    MODEL TRAINING                                   │   │
│  │  Collaborative filtering, content-based, hybrid, ML models          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    REAL-TIME INFERENCE                              │   │
│  │  Generate recommendations in real-time                             │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    PRESENTATION                                    │   │
│  │  App, web, email, push notifications                                │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 2, LESSON 3: PERSONALISATION IN DIGITAL BANKING
# ===================================================================

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.metrics.pairwise import cosine_similarity
from datetime import datetime, timedelta
import warnings
warnings.filterwarnings('ignore')

print("="*70)
print("PERSONALISATION IN DIGITAL BANKING")
print("="*70)

# ----------------------------------------------------------------
# PART A: CUSTOMER SEGMENTATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Customer Segmentation")
print("-"*60)

# Generate synthetic customer data
np.random.seed(42)
n_customers = 1000

customer_data = pd.DataFrame({
    'customer_id': range(1, n_customers+1),
    'age': np.random.normal(45, 15, n_customers).clip(18, 80).astype(int),
    'income': np.random.gamma(5, 20, n_customers) + 20,
    'transaction_count': np.random.gamma(2, 20, n_customers).clip(0, 200).astype(int),
    'avg_transaction': np.random.gamma(2, 50, n_customers).clip(10, 500),
    'account_balance': np.random.gamma(3, 100, n_customers).clip(0, 50000),
    'tenure': np.random.gamma(2, 5, n_customers).clip(0, 20).astype(int),
    'products_count': np.random.choice([1, 2, 3, 4, 5, 6], n_customers, p=[0.2, 0.3, 0.2, 0.15, 0.1, 0.05])
})

print("Customer Data Sample:")
print(customer_data.head())

# Feature engineering for segmentation
features = ['age', 'income', 'transaction_count', 'avg_transaction', 
            'account_balance', 'tenure', 'products_count']
X = customer_data[features]

# Standardise
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# K-Means clustering
kmeans = KMeans(n_clusters=4, random_state=42, n_init=10)
customer_data['segment'] = kmeans.fit_predict(X_scaled)

# Segment profiles
segment_profiles = customer_data.groupby('segment').agg({
    'age': 'mean',
    'income': 'mean',
    'transaction_count': 'mean',
    'avg_transaction': 'mean',
    'account_balance': 'mean',
    'tenure': 'mean',
    'products_count': 'mean',
    'customer_id': 'count'
}).round(2)

segment_profiles.columns = ['Age', 'Income ($k)', 'Transactions', 'Avg Trans ($)', 
                            'Balance ($)', 'Tenure (years)', 'Products', 'Count']

print("\nCustomer Segment Profiles:")
print(segment_profiles)

# Visualise segments
fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# Income vs Age
ax = axes[0, 0]
for segment in customer_data['segment'].unique():
    subset = customer_data[customer_data['segment'] == segment]
    ax.scatter(subset['age'], subset['income'], label=f'Segment {segment}', alpha=0.6)
ax.set_xlabel('Age')
ax.set_ylabel('Income ($k)')
ax.set_title('Customer Segments')
ax.legend()

# Transaction Count vs Average Transaction
ax = axes[0, 1]
for segment in customer_data['segment'].unique():
    subset = customer_data[customer_data['segment'] == segment]
    ax.scatter(subset['transaction_count'], subset['avg_transaction'], label=f'Segment {segment}', alpha=0.6)
ax.set_xlabel('Transaction Count')
ax.set_ylabel('Average Transaction ($)')
ax.set_title('Transaction Behaviour')
ax.legend()

# Product Count by Segment
ax = axes[1, 0]
segment_products = customer_data.groupby('segment')['products_count'].mean()
ax.bar(segment_products.index, segment_products.values, color='teal', alpha=0.7)
ax.set_xlabel('Segment')
ax.set_ylabel('Average Products Count')
ax.set_title('Product Adoption by Segment')

# Segment Distribution
ax = axes[1, 1]
segment_counts = customer_data['segment'].value_counts()
ax.pie(segment_counts.values, labels=segment_counts.index, autopct='%1.1f%%')
ax.set_title('Segment Distribution')

plt.tight_layout()
plt.savefig('customer_segmentation.png', dpi=300, bbox_inches='tight')
plt.show()
print("Customer segmentation visualisation saved as 'customer_segmentation.png'")

# ----------------------------------------------------------------
# PART B: PRODUCT RECOMMENDATION SYSTEM
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Product Recommendation System")
print("-"*60)

# Define products
products = ['Savings Account', 'Checking Account', 'Credit Card', 'Personal Loan', 
            'Mortgage', 'Investment Account', 'Insurance', 'Business Account']

# Simulate customer-product interactions (0 = not owned, 1 = owned)
np.random.seed(42)
interactions = np.random.choice([0, 1], (n_customers, len(products)), p=[0.7, 0.3])
# Ensure customers have at least one product
for i in range(n_customers):
    if interactions[i].sum() == 0:
        interactions[i, np.random.randint(0, len(products))] = 1

# Create product interaction matrix
interaction_df = pd.DataFrame(interactions, columns=products)
customer_data = pd.concat([customer_data, interaction_df], axis=1)

print("Product Interaction Matrix (Sample):")
print(interaction_df.head())

# Collaborative filtering recommendations
def get_product_recommendations(customer_id, interaction_matrix, products, top_n=3):
    """Get product recommendations based on collaborative filtering."""
    # Get the customer's product vector
    customer_vector = interaction_matrix.iloc[customer_id-1].values.reshape(1, -1)
    
    # Calculate similarity with all customers
    similarities = cosine_similarity(customer_vector, interaction_matrix.values)
    similar_customers = np.argsort(similarities[0])[-6:-1]  # Top 5 similar customers
    
    # Get products owned by similar customers
    similar_products = interaction_matrix.iloc[similar_customers].sum(axis=0)
    
    # Remove products already owned by the customer
    owned = interaction_matrix.iloc[customer_id-1] == 1
    similar_products[owned] = 0
    
    # Get top recommendations
    recommended = similar_products.sort_values(ascending=False).head(top_n)
    
    return recommended.index.tolist()

# Get recommendations for a sample customer
sample_customer = 42
recommendations = get_product_recommendations(sample_customer, interaction_df, products)

owned_products = interaction_df.columns[interaction_df.iloc[sample_customer-1] == 1].tolist()

print(f"\nCustomer {sample_customer}:")
print(f"  Owned Products: {owned_products}")
print(f"  Recommended Products: {recommendations}")

# ----------------------------------------------------------------
# PART C: NEXT-BEST-ACTION PREDICTION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Next-Best-Action Prediction")
print("-"*60)

# Simulate next-best-action dataset
np.random.seed(42)
n_actions = 10000

action_data = pd.DataFrame({
    'customer_id': np.random.choice(range(1, n_customers+1), n_actions),
    'action_type': np.random.choice(['Deposit', 'Withdrawal', 'Transfer', 'Payment', 
                                     'Account Opening', 'Loan Application', 
                                     'Investment', 'Insurance Quote'], n_actions),
    'amount': np.random.gamma(3, 50, n_actions),
    'timestamp': [datetime.now() - timedelta(days=np.random.randint(0, 365)) for _ in range(n_actions)]
})

print("Action Data Sample:")
print(action_data.head())

# Feature engineering for action prediction
customer_actions = action_data.groupby('customer_id').agg({
    'action_type': lambda x: x.value_counts().index[0] if len(x) > 0 else 'None',
    'amount': 'mean',
    'timestamp': 'count'
}).reset_index()
customer_actions.columns = ['customer_id', 'most_frequent_action', 'avg_amount', 'action_count']

# Merge with customer data
customer_full = customer_data.merge(customer_actions, on='customer_id', how='left')
customer_full.fillna({'most_frequent_action': 'Unknown', 'avg_amount': 0, 'action_count': 0}, inplace=True)

# Simple heuristic for next-best-action
def predict_nba(row):
    """Simple rule-based next-best-action prediction."""
    if row['products_count'] < 3:
        return 'Increase product adoption'
    elif row['transaction_count'] < 10:
        return 'Increase transaction activity'
    elif row['account_balance'] > 50000:
        return 'Investment advice'
    elif row['age'] > 55:
        return 'Retirement planning'
    else:
        return 'General engagement'

customer_full['next_best_action'] = customer_full.apply(predict_nba, axis=1)

print("\nNext-Best-Action Distribution:")
print(customer_full['next_best_action'].value_counts())

# ----------------------------------------------------------------
# PART D: PERSONALISED OFFER SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Personalised Offer Simulation")
print("-"*60)

# Define offers
offers = {
    'High Spender': {'offer': 'Premium Credit Card', 'condition': 'avg_transaction > 200'},
    'Saver': {'offer': 'High-Yield Savings', 'condition': 'account_balance > 10000'},
    'Investor': {'offer': 'Investment Advisory', 'condition': 'products_count > 3'},
    'New Customer': {'offer': 'Welcome Bonus', 'condition': 'tenure < 1'},
    'Dormant': {'offer': 'Re-engagement Offer', 'condition': 'transaction_count < 5'}
}

# Simulate personalised offers
def generate_personalised_offer(row):
    """Generate a personalised offer based on customer profile."""
    if row['avg_transaction'] > 200:
        return 'Premium Credit Card'
    elif row['account_balance'] > 10000:
        return 'High-Yield Savings'
    elif row['products_count'] > 3:
        return 'Investment Advisory'
    elif row['tenure'] < 1:
        return 'Welcome Bonus'
    elif row['transaction_count'] < 5:
        return 'Re-engagement Offer'
    else:
        return 'Standard Savings Offer'

customer_data['personalised_offer'] = customer_data.apply(generate_personalised_offer, axis=1)

print("\nPersonalised Offer Distribution:")
print(customer_data['personalised_offer'].value_counts())

# Visualise offer distribution by segment
offer_by_segment = customer_data.groupby(['segment', 'personalised_offer']).size().unstack(fill_value=0)

fig, ax = plt.subplots(figsize=(12, 6))
offer_by_segment.plot(kind='bar', ax=ax, stacked=True)
ax.set_xlabel('Segment')
ax.set_ylabel('Number of Customers')
ax.set_title('Personalised Offers by Segment')
ax.legend(loc='best')
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('personalised_offers.png', dpi=300, bbox_inches='tight')
plt.show()
print("Personalised offers visualisation saved as 'personalised_offers.png'")

# ----------------------------------------------------------------
# PART E: PERSONALISATION MATURITY ASSESSMENT
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART E: Personalisation Maturity Assessment")
print("-"*60)

maturity = pd.DataFrame({
    'Dimension': ['Data', 'Segmentation', 'Targeting', 'Recommendation', 'Real-Time', 'Measurement'],
    'Current Level (1-6)': [3, 3, 2, 3, 2, 3],
    'Target Level (1-6)': [5, 5, 5, 5, 4, 5],
    'Gap': [2, 2, 3, 2, 2, 2]
})

print("Personalisation Maturity Assessment:")
print(maturity.to_string(index=False))

# Visualise
fig, ax = plt.subplots(figsize=(10, 6))
x = np.arange(len(maturity))
width = 0.35

ax.bar(x - width/2, maturity['Current Level (1-6)'], width, label='Current', color='blue', alpha=0.7)
ax.bar(x + width/2, maturity['Target Level (1-6)'], width, label='Target', color='green', alpha=0.7)

ax.set_xlabel('Dimension')
ax.set_ylabel('Level (1-6)')
ax.set_title('Personalisation Maturity Assessment')
ax.set_xticks(x)
ax.set_xticklabels(maturity['Dimension'])
ax.legend()
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('personalisation_maturity.png', dpi=300, bbox_inches='tight')
plt.show()
print("Personalisation maturity visualisation saved as 'personalisation_maturity.png'")

# ----------------------------------------------------------------
# PART F: PERSONALISATION STRATEGY RECOMMENDATIONS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART F: Personalisation Strategy Recommendations")
print("-"*60)

strategy = {
    "1. Data Foundation": {
        "Actions": [
            "Build a Customer Data Platform (CDP).",
            "Integrate data across all channels.",
            "Implement real-time data processing.",
            "Ensure data quality and governance."
        ],
        "Priority": "High",
        "Timeline": "0-6 months"
    },
    "2. Segmentation": {
        "Actions": [
            "Implement dynamic segmentation.",
            "Use behavioural and predictive segments.",
            "Segment by customer value and potential.",
            "Create micro-segments for targeting."
        ],
        "Priority": "High",
        "Timeline": "0-6 months"
    },
    "3. Recommendation Systems": {
        "Actions": [
            "Build AI-powered recommendation engine.",
            "Implement hybrid recommendation systems.",
            "Personalise product recommendations.",
            "Add next-best-action capabilities."
        ],
        "Priority": "High",
        "Timeline": "6-12 months"
    },
    "4. Real-Time Personalisation": {
        "Actions": [
            "Implement real-time event processing.",
            "Personalise website and app experiences.",
            "Use context-aware personalisation.",
            "Implement dynamic content delivery."
        ],
        "Priority": "Medium",
        "Timeline": "12-18 months"
    },
    "5. Measurement": {
        "Actions": [
            "Define personalisation KPIs.",
            "Implement A/B testing.",
            "Track business impact (ROI).",
            "Continuously optimise."
        ],
        "Priority": "High",
        "Timeline": "Ongoing"
    }
}

for item, details in strategy.items():
    print(f"\n{item}:")
    for action in details['Actions']:
        print(f"  • {action}")
    print(f"  Priority: {details['Priority']}")
    print(f"  Timeline: {details['Timeline']}")

# ----------------------------------------------------------------
# PART G: SUMMARY AND RECOMMENDATIONS
# ----------------------------------------------------------------

print("\n" + "="*70)
print("PART G: Summary and Recommendations")
print("="*70)

print("""
Personalisation in Digital Banking – Key Takeaways:

1. Personalisation is a key competitive differentiator in banking.
2. Data sources include demographic, transactional, behavioural, and real-time data.
3. Segmentation enables targeted personalisation.
4. Recommendation systems suggest relevant products and actions.
5. Next-best-action predicts the most relevant offer for each customer.
6. Personalisation maturity ranges from basic to hyper-personalisation.
7. Measurement and optimisation are essential for success.

Recommendations:
  - Build a Customer Data Platform (CDP).
  - Implement dynamic segmentation and targeting.
  - Develop AI-powered recommendation systems.
  - Enable real-time personalisation.
  - Measure and optimise personalisation impact.
  - Continuously invest in data and AI capabilities.
""")

print("="*70)
print("END OF LESSON 3 – MODULE 2")
print("="*70)