Distributions

# Import libraries for statistical analysis
import pandas as pd
import numpy as np
from scipy import stats
import matplotlib.pyplot as plt

# Load ecommerce data to analyze customer ages
df = pd.read_csv('dataplexa_ecommerce.csv')
print(df.head())

# Calculate descriptive statistics for customer ages
age_stats = df['customer_age'].describe()
print("Age Distribution Summary:")
print(age_stats)

# Extract mean and standard deviation for normal distribution
mean_age = df['customer_age'].mean()
std_age = df['customer_age'].std()
print(f"\nMean age: {mean_age:.2f}")
print(f"Standard deviation: {std_age:.2f}")

# Test if data follows normal distribution using Shapiro-Wilk test
# Sample 1000 rows because Shapiro-Wilk works best on smaller samples
sample_ages = df['customer_age'].sample(1000, random_state=42)
statistic, p_value = stats.shapiro(sample_ages)

print("Shapiro-Wilk Normality Test:")
print(f"Test statistic: {statistic:.4f}")
print(f"P-value: {p_value:.6f}")
print(f"Is normal? {p_value > 0.05}")

# Calculate conversion rates from our ecommerce data
# Assume purchase (non-return) is a conversion
df['converted'] = ~df['returned']  # True if not returned
total_orders = len(df)
conversions = df['converted'].sum()
conversion_rate = conversions / total_orders

print(f"Total orders: {total_orders}")
print(f"Successful conversions: {conversions}")
print(f"Conversion rate: {conversion_rate:.3f}")

# Model email campaign with binomial distribution
# n = trials (emails sent), p = conversion probability
n_emails = 1000
p_convert = 0.15  # 15% expected conversion rate

# Calculate expected conversions and confidence interval
expected_conversions = n_emails * p_convert
variance = n_emails * p_convert * (1 - p_convert)
std_dev = np.sqrt(variance)

print(f"Campaign size: {n_emails} emails")
print(f"Expected conversions: {expected_conversions:.0f}")
print(f"Standard deviation: {std_dev:.2f}")

# Calculate confidence intervals using binomial distribution
# 95% confidence interval (2.5% to 97.5% percentiles)
lower_bound = stats.binom.ppf(0.025, n_emails, p_convert)
upper_bound = stats.binom.ppf(0.975, n_emails, p_convert)

# Calculate probability of getting exactly 160 conversions
prob_160 = stats.binom.pmf(160, n_emails, p_convert)

print("95% Confidence Interval:")
print(f"Lower bound: {lower_bound:.0f} conversions")
print(f"Upper bound: {upper_bound:.0f} conversions")
print(f"Probability of exactly 160: {prob_160:.4f}")

# Simulate rare events using order returns as proxy
# Count returns per day to model rare event frequency
df['date'] = pd.to_datetime(df['date'])
daily_returns = df[df['returned'] == True].groupby('date').size()

# Calculate average returns per day (lambda parameter)
lambda_param = daily_returns.mean()
total_days = len(daily_returns)

print(f"Total observation days: {total_days}")
print(f"Average returns per day: {lambda_param:.2f}")
print(f"This is our λ (lambda) parameter")

# Calculate probabilities for different event counts
# Probability of exactly 0, 1, 5, or 10 returns in a day
events = [0, 1, 5, 10]
probabilities = []

for k in events:
    prob = stats.poisson.pmf(k, lambda_param)
    probabilities.append(prob)
    print(f"P(exactly {k} returns) = {prob:.4f}")

# Calculate cumulative probability (5 or fewer returns)
cumulative_prob = stats.poisson.cdf(5, lambda_param)
print(f"\nP(≤5 returns per day) = {cumulative_prob:.4f}")

# Quick distribution identification function
def identify_distribution(data):
    """Suggests distribution type based on data characteristics"""
    
    # Check if data is binary (0/1 or True/False)
    unique_values = data.nunique()
    if unique_values == 2:
        return "Binomial (for count of successes)"
    
    # Check if data contains only non-negative integers
    if (data >= 0).all() and (data % 1 == 0).all():
        if data.mean() < 10:
            return "Poisson (rare events)"
        else:
            return "Normal approximation to Poisson"

# Test distribution identification on different columns
test_columns = ['customer_age', 'quantity', 'returned']

for col in test_columns:
    suggestion = identify_distribution(df[col])
    mean_val = df[col].mean()
    print(f"{col}:")
    print(f"  Mean: {mean_val:.2f}")
    print(f"  Suggested: {suggestion}")
    print()