Predict which volunteers might leave

Predict volunteer churn using Random Forest

This builds a model to predict which volunteers are likely to leave. Adapt the feature calculations to your data.

import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from datetime import datetime, timedelta

# Load volunteer data
# Expected: volunteer_id, shift_date, role, start_date, end_date (if left)
shifts = pd.read_csv('volunteer_shifts.csv')
shifts['shift_date'] = pd.to_datetime(shifts['shift_date'])

volunteers = pd.read_csv('volunteers.csv')
volunteers['start_date'] = pd.to_datetime(volunteers['start_date'])
volunteers['end_date'] = pd.to_datetime(volunteers['end_date'], errors='coerce')

print(f"Loaded {len(volunteers)} volunteers, {len(shifts)} shift records")

# Calculate features for each volunteer
def calculate_features(volunteer_id, as_of_date):
    """Calculate behavioral features as of a specific date"""

    vol_shifts = shifts[
        (shifts['volunteer_id'] == volunteer_id) &
        (shifts['shift_date'] <= as_of_date)
    ].sort_values('shift_date')

    if len(vol_shifts) == 0:
        return None

    # Basic stats
    features = {
        'total_shifts': len(vol_shifts),
        'days_since_start': (as_of_date - vol_shifts['shift_date'].min()).days,
        'days_since_last_shift': (as_of_date - vol_shifts['shift_date'].max()).days,
    }

    # Attendance trend (last 3 months vs previous 3 months)
    recent_cutoff = as_of_date - timedelta(days=90)
    previous_cutoff = as_of_date - timedelta(days=180)

    recent_shifts = len(vol_shifts[vol_shifts['shift_date'] >= recent_cutoff])
    previous_shifts = len(vol_shifts[
        (vol_shifts['shift_date'] >= previous_cutoff) &
        (vol_shifts['shift_date'] < recent_cutoff)
    ])

    features['recent_shifts_3mo'] = recent_shifts
    features['previous_shifts_3mo'] = previous_shifts

    # Calculate trend (positive = increasing, negative = declining)
    if previous_shifts > 0:
        features['attendance_trend'] = (recent_shifts - previous_shifts) / previous_shifts
    else:
        features['attendance_trend'] = 0

    # Gap analysis
    if len(vol_shifts) > 1:
        gaps = vol_shifts['shift_date'].diff().dt.days.dropna()
        features['avg_gap_days'] = gaps.mean()
        features['max_gap_days'] = gaps.max()
    else:
        features['avg_gap_days'] = 0
        features['max_gap_days'] = 0

    return features

# Build training dataset from historical data
# For volunteers who left: predict if they would leave 3 months before actual departure
# For volunteers who stayed: sample random points to check

training_data = []

for _, vol in volunteers.iterrows():
    vol_id = vol['volunteer_id']

    if pd.notna(vol['end_date']):  # Volunteer left
        # Sample 3 months before they left
        prediction_date = vol['end_date'] - timedelta(days=90)

        if prediction_date > vol['start_date']:
            features = calculate_features(vol_id, prediction_date)
            if features:
                features['volunteer_id'] = vol_id
                features['will_leave'] = 1  # Left within 3 months
                training_data.append(features)

    else:  # Still active - sample from their history
        # Take multiple snapshots during their tenure
        start = vol['start_date']
        today = pd.Timestamp.now()

        # Sample every 3 months they've been active
        sample_date = start + timedelta(days=90)
        while sample_date < today:
            features = calculate_features(vol_id, sample_date)
            if features:
                features['volunteer_id'] = vol_id
                features['will_leave'] = 0  # Still active
                training_data.append(features)

            sample_date += timedelta(days=90)

# Create training dataframe
train_df = pd.DataFrame(training_data)
print(f"\nTraining samples: {len(train_df)}")
print(f"  Left: {len(train_df[train_df['will_leave'] == 1])}")
print(f"  Stayed: {len(train_df[train_df['will_leave'] == 0])}")

# Prepare features and target
feature_cols = [
    'total_shifts', 'days_since_start', 'days_since_last_shift',
    'recent_shifts_3mo', 'previous_shifts_3mo', 'attendance_trend',
    'avg_gap_days', 'max_gap_days'
]

X = train_df[feature_cols]
y = train_df['will_leave']

# Split into train/test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Train Random Forest
rf = RandomForestClassifier(n_estimators=100, random_state=42, max_depth=5)
rf.fit(X_train, y_train)

# Evaluate
y_pred = rf.predict(X_test)
print("\nModel Performance:")
print(classification_report(y_test, y_pred, target_names=['Will Stay', 'Will Leave']))

# Feature importance
feature_importance = pd.DataFrame({
    'feature': feature_cols,
    'importance': rf.feature_importances_
}).sort_values('importance', ascending=False)

print("\nMost important factors predicting departure:")
print(feature_importance.head())

# Score current volunteers
print("\nScoring current active volunteers...")
current_volunteers = volunteers[volunteers['end_date'].isna()]

risk_scores = []
today = pd.Timestamp.now()

for _, vol in current_volunteers.iterrows():
    features_dict = calculate_features(vol['volunteer_id'], today)

    if features_dict:
        features_array = [features_dict[col] for col in feature_cols]
        risk_prob = rf.predict_proba([features_array])[0][1]  # Probability of leaving

        risk_scores.append({
            'volunteer_id': vol['volunteer_id'],
            'risk_score': round(risk_prob * 100, 1),
            'days_since_last': features_dict['days_since_last_shift'],
            'attendance_trend': round(features_dict['attendance_trend'], 2),
            'recent_shifts': features_dict['recent_shifts_3mo']
        })

# Sort by risk
risk_df = pd.DataFrame(risk_scores).sort_values('risk_score', ascending=False)

print(f"\nHigh risk volunteers (70%+ likely to leave):")
high_risk = risk_df[risk_df['risk_score'] >= 70]
print(high_risk.to_string(index=False))

print(f"\nMedium risk (50-70%):")
medium_risk = risk_df[(risk_df['risk_score'] >= 50) & (risk_df['risk_score'] < 70)]
print(medium_risk.head(10).to_string(index=False))

# Export for action
risk_df.to_csv('volunteer_retention_risk.csv', index=False)
print("\nFull risk scores saved to volunteer_retention_risk.csv")
print("\nNext steps:")
print("1. Reach out to high-risk volunteers")
print("2. Investigate what's changed for them")
print("3. Address barriers to continued engagement")
print("4. Retrain model monthly with new data")