Supervised Learning Example (Python)

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report

# Load and prepare data
customer_data = pd.read_csv('customer_churn.csv')
X = customer_data.drop('churn', axis=1)
y = customer_data['churn']

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Train a Random Forest model
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Make predictions
predictions = model.predict(X_test)

# Evaluate the model
accuracy = accuracy_score(y_test, predictions)
print(f"Model Accuracy: {accuracy:.2f}")
print(classification_report(y_test, predictions))

# Feature importance
feature_importance = pd.DataFrame({
    'Feature': X.columns,
    'Importance': model.feature_importances_
}).sort_values('Importance', ascending=False)
print(feature_importance.head(10))

Problem Statement

A manufacturing company wants to minimize inventory costs while ensuring sufficient stock to meet customer demand.

Data Analysis Approach

1. Descriptive Analysis: Examine historical inventory levels, stockout incidents, and carrying costs
2. Exploratory Analysis: Identify patterns in demand fluctuations and supplier lead times
3. Predictive Analysis: Forecast future demand based on historical patterns and external factors
4. Prescriptive Analysis: Determine optimal reorder points and quantities for each product

Implementation

# Python example of inventory optimization analysis
import pandas as pd
import numpy as np
from statsmodels.tsa.holtwinters import ExponentialSmoothing

# Load historical demand data
demand_data = pd.read_csv('monthly_demand.csv', parse_dates=['date'])
demand_data = demand_data.set_index('date')

# Forecast future demand using Holt-Winters exponential smoothing
def forecast_demand(product_id, periods=3):
    product_demand = demand_data[demand_data['product_id'] == product_id]['quantity']
    model = ExponentialSmoothing(product_demand, 
                                trend='add', 
                                seasonal='add', 
                                seasonal_periods=12)
    model_fit = model.fit()
    forecast = model_fit.forecast(periods)
    return forecast

# Calculate safety stock based on service level and lead time variability
def calculate_safety_stock(product_id, service_level=0.95, lead_time=14):
    product_demand = demand_data[demand_data['product_id'] == product_id]['quantity']
    daily_demand = product_demand.resample('D').mean().fillna(0)
    
    # Standard deviation of daily demand
    daily_std = daily_demand.std()
    
    # Lead time standard deviation (assuming it's known)
    lead_time_std = 3  
    
    # Safety factor based on service level (normal distribution)
    from scipy.stats import norm
    z = norm.ppf(service_level)
    
    # Calculate safety stock
    safety_stock = z * np.sqrt(lead_time * daily_std**2 + daily_demand.mean()**2 * lead_time_std**2)
    
    return safety_stock

# Calculate economic order quantity (EOQ)
def calculate_eoq(product_id, ordering_cost=100, holding_cost_percent=0.25):
    product_demand = demand_data[demand_data['product_id'] == product_id]['quantity']
    annual_demand = product_demand.sum() * (365 / len(product_demand))
    
    # Get product cost from product master data
    product_cost = product_master[product_master['product_id'] == product_id]['cost'].values[0]
    
    # Calculate holding cost per unit
    holding_cost = product_cost * holding_cost_percent
    
    # Calculate EOQ
    eoq = np.sqrt((2 * annual_demand * ordering_cost) / holding_cost)
    
    return eoq

Results and Benefits

• Reduced inventory carrying costs by 18%
• Decreased stockout incidents by 22%
• Optimized warehouse space utilization
• Improved cash flow by reducing excess inventory

Problem Statement

An online subscription service wants to identify customers at risk of cancellation before they churn.

Data Analysis Approach

1. Descriptive Analysis: Calculate historical churn rates by customer segments
2. Exploratory Analysis: Identify factors correlated with churn
3. Predictive Analysis: Build a model to predict the probability of customer churn
4. Prescriptive Analysis: Develop targeted retention strategies for high-risk customers

Key Findings

• Customers who contact support more than twice in a month are 3x more likely to churn
• Usage decline of >40% over two consecutive months is a strong churn indicator
• New feature adoption within the first 30 days reduces churn probability by 45%
• Customers on monthly billing plans churn at 2.5x the rate of annual subscribers

Model Performance

The final Random Forest model achieved:

• AUC-ROC: 0.86
• Precision: 0.78
• Recall: 0.73
• F1 Score: 0.75

Business Impact

• 15% reduction in overall churn rate
• 23% higher conversion rate for retention campaigns by targeting high-risk customers
• $1.2M annual revenue saved through prevented churn

Problem Statement

A hospital aims to reduce 30-day readmission rates for patients with chronic conditions.

Data Analysis Approach

1. Data Collection: Gathered patient demographics, medical history, treatments, medications, discharge instructions, and post-discharge activities
2. Exploratory Analysis: Identified patterns in readmissions across different patient populations
3. Feature Engineering: Created variables such as comorbidity indices, medication complexity scores, and social support indicators
4. Model Development: Built and compared multiple predictive models (Logistic Regression, Random Forest, Gradient Boosting)

Key Findings

• Five strongest predictors of readmission:
  1. Number of previous admissions in the past year
  2. Length of initial hospital stay
  3. Number of comorbidities
  4. Medication adherence score
  5. Availability of post-discharge support
• Patients with 4+ medications have 2.3x higher readmission risk
• Follow-up appointment within 7 days reduces readmission risk by 37%

Intervention Strategy

The hospital implemented a risk-stratified care management approach:

• High-risk patients: Personalized care plans, home visits, daily check-ins
• Medium-risk patients: Scheduled follow-up calls, medication reviews
• Low-risk patients: Standard discharge procedures

Results

• 19% reduction in 30-day readmission rates
• Estimated $2.7M annual savings in readmission costs
• Improved patient satisfaction scores by 14%

Problem Statement

Public health officials need to analyze the spread of an infectious disease to optimize resource allocation and intervention strategies.

Data Analysis Approach

1. Data Collection: Case reports, testing data, hospital admissions, geographic information, demographic data
2. Descriptive Analysis: Track case counts, testing rates, positivity rates, hospitalizations by region
3. Spatial Analysis: Map hotspots and transmission patterns
4. Time Series Analysis: Model disease progression and reproduction rates
5. Predictive Modeling: Forecast case loads and hospital capacity needs

Visualizations Used

• Heat maps showing case density by geographic area
• Epidemic curves tracking cases over time
• Network diagrams illustrating transmission chains
• Forecasting models with confidence intervals

Key Findings

• Early detection of emerging hotspots 7-10 days before significant case increases
• Identification of superspreader events and high-risk activities
• Determination of most effective intervention combinations (e.g., masking + capacity limits reduced transmission by 34%)
• Accurate forecasting of hospital capacity needs with 85% accuracy at 14-day horizon

Impact

• Optimized testing resource allocation to high-need areas
• Targeted public health messaging to vulnerable communities
• Proactive hospital staffing based on forecasted needs
• Data-driven policy decisions on intervention measures

Problem Statement

A financial institution needs to identify fraudulent transactions while minimizing false positives that disrupt legitimate customer activities.

Data Analysis Approach

1. Data Collection: Transaction details, customer profiles, device information, location data
2. Exploratory Analysis: Identify patterns in known fraudulent transactions
3. Feature Engineering: Create behavior-based features (deviation from typical spending patterns, unusual locations, etc.)
4. Model Development: Build an ensemble of models with different strengths
5. Real-time Scoring: Implement a system to score transactions as they occur

Technical Implementation

# Simplified code example of a fraud detection system
import pandas as pd
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, confusion_matrix
from sklearn.preprocessing import StandardScaler
import numpy as np

# Load and prepare data
transactions = pd.read_csv('transactions.csv')

# Feature engineering
def engineer_features(df):
    # Add time-based features
    df['hour_of_day'] = df['timestamp'].dt.hour
    df['day_of_week'] = df['timestamp'].dt.dayofweek
    df['weekend'] = df['day_of_week'].apply(lambda x: 1 if x >= 5 else 0)
    
    # Calculate customer spending patterns
    customer_avg = df.groupby('customer_id')['amount'].agg(['mean', 'std']).reset_index()
    df = pd.merge(df, customer_avg, on='customer_id', how='left')
    df['amount_zscore'] = (df['amount'] - df['mean']) / df['std']
    
    # Location-based features
    df['new_location'] = np.where(
        df.groupby('customer_id')['location_id'].transform(
            lambda x: ~x.isin(x.iloc[:-1].values)
        ), 
        1, 0
    )
    
    # Velocity checks (multiple transactions in short time)
    df['tx_count_1h'] = df.groupby('customer_id')['timestamp'].transform(
        lambda x: x.rolling('1h').count() - 1
    )
    
    return df

# Feature engineering
transactions = engineer_features(transactions)

# Prepare features and target
features = ['amount', 'amount_zscore', 'hour_of_day', 'weekend', 
            'new_location', 'tx_count_1h', 'device_age_days',
            'distance_from_home_km']
X = transactions[features]
y = transactions['is_fraud']

# Split data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Scale features
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Train models
models = {
    'logistic': LogisticRegression(class_weight='balanced'),
    'random_forest': RandomForestClassifier(n_estimators=100, class_weight='balanced'),
    'gradient_boosting': GradientBoostingClassifier(n_estimators=100)
}

for name, model in models.items():
    model.fit(X_train_scaled, y_train)
    y_pred = model.predict(X_test_scaled)
    print(f"Model: {name}")
    print(confusion_matrix(y_test, y_pred))
    print(classification_report(y_test, y_pred))

# Function for real-time fraud scoring
def score_transaction(transaction, models, scaler):
    # Preprocess the transaction
    features = engineer_features(pd.DataFrame([transaction]))
    features_scaled = scaler.transform(features[features_list])
    
    # Get predictions from all models
    scores = {}
    for name, model in models.items():
        if hasattr(model, 'predict_proba'):
            scores[name] = model.predict_proba(features_scaled)[0][1]
        else:
            scores[name] = model.predict(features_scaled)[0]
    
    # Weighted ensemble
    final_score = (0.2 * scores['logistic'] + 
                  0.4 * scores['random_forest'] + 
                  0.4 * scores['gradient_boosting'])
    
    return final_score, final_score > 0.75  # Flag as fraudulent if score > 0.75

Results

• Increased fraud detection rate from 74% to 92%
• Reduced false positive rate from 1:15 to 1:42
• Estimated annual savings of $4.8M in prevented fraud
• Improved customer experience through fewer legitimate transaction declines

Problem Statement

An investment firm wants to optimize client portfolios to maximize returns while managing risk according to client risk tolerance.

Data Analysis Approach

1. Historical Analysis: Analyze asset performance across different market conditions
2. Risk Assessment: Calculate volatility, Value at Risk (VaR), and maximum drawdowns
3. Correlation Analysis: Identify diversification opportunities through asset correlation
4. Optimization Modeling: Apply Modern Portfolio Theory and efficient frontier analysis
5. Monte Carlo Simulation: Project thousands of possible future scenarios

Key Components

• Expected Return Estimation: Using capital asset pricing model (CAPM) and multi-factor models
• Risk Measurement: Standard deviation, beta, downside risk metrics
• Portfolio Construction: Efficient frontier optimization for different risk tolerance levels
• Rebalancing Strategies: Threshold-based and calendar-based approaches

Visualization Example

Efficient Frontier showing risk-return tradeoffs with optimal portfolios for different risk profiles

Client Implementation

The firm created five model portfolios based on risk profiles:

1. Conservative: 20% equity, 70% fixed income, 10% alternatives
2. Moderately Conservative: 40% equity, 50% fixed income, 10% alternatives
3. Balanced: 60% equity, 30% fixed income, 10% alternatives
4. Growth: 75% equity, 15% fixed income, 10% alternatives
5. Aggressive Growth: 90% equity, 0% fixed income, 10% alternatives

Results

• Risk-adjusted returns (Sharpe ratio) improved by 0.24 on average
• Client portfolios outperformed benchmarks by 1.2-2.7% annually
• Maximum drawdowns during market corrections reduced by 15-20%
• Higher client satisfaction and retention rates

Problem Statement

An e-commerce company wants to create personalized marketing campaigns by segmenting customers based on their behaviors and preferences.

Data Analysis Approach

1. Data Collection: Purchase history, browsing behavior, email engagement, demographics, return patterns
2. RFM Analysis: Calculate Recency, Frequency, and Monetary value metrics
3. Exploratory Analysis: Identify natural groupings in customer behavior
4. Cluster Analysis: Apply K-means and hierarchical clustering algorithms
5. Profiling: Characterize each segment by their defining attributes

Implementation

# Python example of customer segmentation using K-means clustering
import pandas as pd
import numpy as np
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt
import seaborn as sns

# Load customer data
customer_data = pd.read_csv('customer_data.csv')

# Calculate RFM metrics
def calculate_rfm(df):
    # Setting the end date as the max date in the dataset + 1 day
    max_date = df['purchase_date'].max() + pd.Timedelta(days=1)
    
    # Calculate Recency (days since last purchase)
    rfm_recency = df.groupby('customer_id')['purchase_date'].max()
    rfm_recency = (max_date - rfm_recency).dt.days
    
    # Calculate Frequency (count of purchases)
    rfm_frequency = df.groupby('customer_id')['order_id'].count()
    
    # Calculate Monetary (total spent)
    rfm_monetary = df.groupby('customer_id')['total_amount'].sum()
    
    # Combine into a single DataFrame
    rfm = pd.DataFrame({
        'Recency': rfm_recency,
        'Frequency': rfm_frequency,
        'Monetary': rfm_monetary
    })
    
    return rfm

# Calculate RFM
rfm_df = calculate_rfm(customer_data)

# Scale the data
scaler = StandardScaler()
rfm_scaled = scaler.fit_transform(rfm_df)

# Determine optimal number of clusters using the Elbow Method
sse = {}
for k in range(1, 11):
    kmeans = KMeans(n_clusters=k, random_state=42)
    kmeans.fit(rfm_scaled)
    sse[k] = kmeans.inertia_

plt.figure(figsize=(10, 6))
plt.plot(list(sse.keys()), list(sse.values()), 'bx-')
plt.xlabel('Number of clusters')
plt.ylabel('Sum of Squared Distances')
plt.title('Elbow Method For Optimal k')
plt.show()

# Apply K-means with the chosen number of clusters (e.g., 5)
kmeans = KMeans(n_clusters=5, random_state=42)
rfm_df['Cluster'] = kmeans.fit_predict(rfm_scaled)

# Analyze the clusters
cluster_stats = rfm_df.groupby('Cluster').agg({
    'Recency': ['mean', 'min', 'max'],
    'Frequency': ['mean', 'min', 'max'],
    'Monetary': ['mean', 'min', 'max'],
}).round(2)

print(cluster_stats)

# Create customer segments based on clustering
def create_segment_labels(row):
    if row['Cluster'] == 0:
        return 'Loyal High-Spenders'
    elif row['Cluster'] == 1:
        return 'Potential Loyalists'
    elif row['Cluster'] == 2:
        return 'At-Risk Customers'
    elif row['Cluster'] == 3:
        return 'New Customers'
    else:
        return 'Hibernating Customers'

rfm_df['Segment'] = rfm_df.apply(create_segment_labels, axis=1)

# Visualize the segments
plt.figure(figsize=(12, 8))
sns.scatterplot(x='Recency', y='Monetary', hue='Segment', size='Frequency', 
                sizes=(20, 200), data=rfm_df, palette='viridis')
plt.title('Customer Segments')
plt.xlabel('Recency (days)')
plt.ylabel('Monetary (total spent)')
plt.show()

Identified Customer Segments

1. Champions (15%): High spending, frequent purchases, recent engagement
2. Loyal Customers (23%): Consistent spending, above-average frequency
3. Potential Loyalists (21%): Recent customers with promising purchase patterns
4. At-Risk Customers (18%): Previously active but declining engagement
5. Hibernating Customers (23%): Low activity, infrequent purchases

Targeted Marketing Strategies

• Champions: Loyalty rewards, exclusive previews, referral programs
• Loyal Customers: Retention offers, cross-selling, special events
• Potential Loyalists: Onboarding series, second purchase incentives
• At-Risk: Reactivation campaigns, feedback surveys, special offers
• Hibernating: Win-back campaigns, major promotions

Results

• Email campaign engagement increased by 34%
• Conversion rates improved by 28% through targeted messaging
• Customer retention rate increased from 67% to 78%
• Marketing ROI improved by 41% through optimized spending by segment

Problem Statement

A company needs to understand which marketing channels and touchpoints contribute most effectively to conversions and how to optimize marketing spend.

Data Analysis Approach

1. Data Collection: User journey data, touchpoint timestamps, channel information, conversion data
2. Journey Mapping: Create visual representations of customer paths to conversion
3. Basic Attribution Models: Apply first-touch, last-touch, and linear attribution models
4. Advanced Attribution: Implement data-driven multi-touch attribution using Markov Chains
5. ROAS Analysis: Calculate return on ad spend by channel using attributed conversions

Attribution Model Comparison

Key Insights

• Email marketing was undervalued by 11% in first-touch attribution
• Organic search contribution was 8% higher than shown in last-touch attribution
• Display advertising showed lower incremental value in data-driven models
• Average customer journey included 3.7 touchpoints before conversion
• Certain channel combinations (social → email → paid search) showed 2.4x higher conversion rates

Optimized Marketing Budget Allocation

Based on the Markov Chain attribution model, the company implemented the following changes:

• Increased organic search budget by 15%
• Maintained paid search investment
• Increased email marketing budget by 22%
• Reduced display advertising spend by 18%
• Optimized timing of touchpoints based on journey analysis

Results

• Overall marketing ROI improved by 24%
• Cost per acquisition decreased by 16%
• Conversion rate increased by 9%
• Total marketing spend reduced by 12% while maintaining conversion volume