Forecast event attendance

Forecast event attendance

This predicts attendance based on historical patterns. Adapt features to factors that affect your events.

import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error, r2_score
from datetime import datetime

# Load historical event data
# Columns: event_name, date, registrations, actual_attendance, day_of_week, topic, format, etc.
events = pd.read_csv('historical_events.csv')
events['date'] = pd.to_datetime(events['date'])

print(f"Loaded {len(events)} historical events")

# Calculate show-up rate
events['show_up_rate'] = events['actual_attendance'] / events['registrations']
avg_show_up = events['show_up_rate'].mean()

print(f"Average show-up rate: {avg_show_up*100:.1f}%")
print(f"Show-up rate range: {events['show_up_rate'].min()*100:.1f}% to {events['show_up_rate'].max()*100:.1f}%")

# Extract time-based features
events['month'] = events['date'].dt.month
events['day_of_week_num'] = events['date'].dt.dayofweek  # 0=Monday, 6=Sunday
events['is_weekend'] = (events['day_of_week_num'] >= 5).astype(int)
events['quarter'] = events['date'].dt.quarter

# Encode categorical variables
# NOTE: Using category codes gives arbitrary numbers (0, 1, 2...) which the model
# treats as having mathematical order. For small numbers of categories (3-5) this
# usually works fine. For many categories or if you see odd results, consider
# using OneHotEncoder instead, which creates separate binary columns per category.
# Topic/event type
events['topic_encoded'] = pd.Categorical(events['topic']).codes

# Format (in-person, online, hybrid)
events['format_encoded'] = pd.Categorical(events['format']).codes

# Define features for prediction
feature_cols = [
    'registrations',  # How many signed up
    'month',  # Seasonal effects
    'is_weekend',  # Weekend vs weekday
    'topic_encoded',  # Event topic/type
    'format_encoded',  # In-person/online/hybrid
]

# Optional: add more features if you have them
# 'is_free', 'has_celebrity_speaker', 'days_notice', etc.

X = events[feature_cols]
y = events['actual_attendance']

# 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 model
rf = RandomForestRegressor(n_estimators=100, random_state=42, max_depth=5)
rf.fit(X_train, y_train)

# Evaluate
y_pred = rf.predict(X_test)
mae = mean_absolute_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print(f"\nModel Performance:")
print(f"  Mean Absolute Error: {mae:.1f} people")
print(f"  R² Score: {r2:.2f}")
print(f"  (On average, predictions are within {mae:.0f} people of actual attendance)")

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

print("\nMost important factors for attendance:")
print(feature_importance)

# Function to forecast new event
def forecast_attendance(registrations, month, is_weekend, topic, format_type):
    """
    Forecast attendance for upcoming event
    """
    # Encode categorical values (must match training)
    topic_code = pd.Categorical([topic], categories=events['topic'].unique()).codes[0]
    format_code = pd.Categorical([format_type], categories=events['format'].unique()).codes[0]

    # Create features array
    features = [[
        registrations,
        month,
        1 if is_weekend else 0,
        topic_code,
        format_code
    ]]

    # Predict
    predicted_attendance = rf.predict(features)[0]

    # Calculate confidence interval (based on model error)
    lower_bound = predicted_attendance - (mae * 1.5)
    upper_bound = predicted_attendance + (mae * 1.5)

    # Ensure bounds make sense
    lower_bound = max(0, lower_bound)
    upper_bound = min(registrations, upper_bound)  # Can't exceed registrations

    return {
        'predicted_attendance': round(predicted_attendance),
        'lower_bound': round(lower_bound),
        'upper_bound': round(upper_bound),
        'show_up_rate_predicted': predicted_attendance / registrations if registrations > 0 else 0
    }

# Example: Forecast for upcoming event
upcoming_event = {
    'registrations': 85,
    'month': 10,  # October
    'is_weekend': True,  # Saturday
    'topic': 'Fundraising Workshop',  # Must be a topic from training data
    'format': 'in-person'  # Must be a format from training data
}

forecast = forecast_attendance(
    upcoming_event['registrations'],
    upcoming_event['month'],
    upcoming_event['is_weekend'],
    upcoming_event['topic'],
    upcoming_event['format']
)

print(f"\n{'='*60}")
print("ATTENDANCE FORECAST FOR UPCOMING EVENT:")
print(f"{'='*60}")
print(f"\nEvent Details:")
print(f"  Registrations: {upcoming_event['registrations']}")
print(f"  Date: October, Weekend")
print(f"  Topic: {upcoming_event['topic']}")
print(f"  Format: {upcoming_event['format']}")

print(f"\nForecast:")
print(f"  Expected attendance: {forecast['predicted_attendance']} people")
print(f"  Range (80% confidence): {forecast['lower_bound']}-{forecast['upper_bound']} people")
print(f"  Predicted show-up rate: {forecast['show_up_rate_predicted']*100:.1f}%")

print(f"\nPlanning Recommendations:")
# Catering (predicted + buffer)
catering = forecast['predicted_attendance'] + 5
print(f"  Catering: Order for {catering} people (forecast + 5 buffer)")

# Venue capacity
venue_capacity = forecast['upper_bound'] + 10
print(f"  Venue: Ensure capacity for {venue_capacity}+ people")

# Materials
materials = forecast['predicted_attendance']
print(f"  Printed materials: {materials} copies")

# Overflow planning
if forecast['upper_bound'] > upcoming_event['registrations'] * 0.9:
    print(f"  ⚠️  High attendance expected - consider overflow plan")

print(f"\n{'='*60}")

# Save forecasting function
print("\nModel trained and ready for forecasting.")
print("Update with actual attendance after events to improve accuracy.")