Types of Case Studies in Data Analysis & Visualization

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

# ── Step 1: Load & Inspect ──────────────────────
df = pd.read_csv('transactions.csv', parse_dates=['date'])
print(df.info())
print(df.describe())

# ── Step 2: Missing Values ──────────────────────
missing = df.isnull().sum() / len(df) * 100
print(missing[missing > 0].sort_values(ascending=False))

# ── Step 3: Distribution of Sales ──────────────
plt.figure(figsize=(12, 4))
sns.histplot(df['sales_amount'], bins=60, kde=True, color='#f0a500')
plt.title('Sales Distribution')
plt.show()

# ── Step 4: Correlation Heatmap ─────────────────
corr = df.select_dtypes(include='number').corr()
sns.heatmap(corr, annot=True, fmt='.2f', cmap='coolwarm')
plt.title('Feature Correlation Matrix')
plt.show()

# ── Step 5: Seasonal Pattern ────────────────────
df['month'] = df['date'].dt.month_name()
monthly = df.groupby('month')['sales_amount'].sum()
print(monthly.sort_values(ascending=False))

import pandas as pd
import plotly.express as px

df = pd.read_csv('patient_admissions.csv', parse_dates=['admission_date'])

# ── Monthly admissions ──────────────────────────
df['month'] = df['admission_date'].dt.to_period('M')
monthly = df.groupby('month').agg(
    total_admissions=('patient_id', 'count'),
    avg_stay_days=('length_of_stay', 'mean'),
    readmissions=('is_readmission', 'sum')
).reset_index()

# ── Top diagnoses ───────────────────────────────
top_dx = (df['diagnosis']
           .value_counts()
           .head(10)
           .reset_index())
top_dx.columns = ['diagnosis', 'count']

# ── Readmission rate by region ──────────────────
region_stats = df.groupby('region').agg(
    total=('patient_id', 'count'),
    readmit_rate=('is_readmission', 'mean')
).sort_values('readmit_rate', ascending=False)

# ── Interactive chart with Plotly ───────────────
fig = px.bar(monthly, x='month', y='total_admissions',
             title='Monthly Patient Admissions',
             color='total_admissions',
             color_continuous_scale='teal')
fig.show()

from scipy import stats
import numpy as np

# ── Sample Data ─────────────────────────────────
control_n, control_conv = 15000, 1350   # 9.0%
treat_n, treat_conv   = 14800, 1628   # 11.0%

# ── Conversion Rates ────────────────────────────
p_control = control_conv / control_n
p_treat   = treat_conv   / treat_n
print(f"Control: {p_control:.1%} | Treatment: {p_treat:.1%}")
print(f"Absolute lift: {p_treat - p_control:.1%}")

# ── Two-proportion z-test ───────────────────────
count = np.array([treat_conv, control_conv])
nobs  = np.array([treat_n, control_n])
from statsmodels.stats.proportion import proportions_ztest
z_stat, p_val = proportions_ztest(count, nobs)
print(f"z={z_stat:.3f}, p={p_val:.4f}")
if p_val < 0.05:
    print("✓ Statistically significant — roll out the new design!")
else:
    print("✗ Not significant — more data needed.")

import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt

# ── Feature Matrix ──────────────────────────────
features = ['is_treatment', 'is_mobile', 'page_load_time',
            'items_in_cart', 'is_returning_user']
X = df[features]
y = df['converted']

# ── Scale & Fit ─────────────────────────────────
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
model = LogisticRegression().fit(X_scaled, y)

# ── Visualize Coefficients ──────────────────────
coef_df = pd.DataFrame({
    'feature': features,
    'coef':    model.coef_[0]
}).sort_values('coef')
coef_df.plot(kind='barh', x='feature', y='coef',
            color='#ef476f', legend=False)
plt.title('What Drives Conversion? (Logistic Coeff.)')
plt.show()

from prophet import Prophet
import pandas as pd
import plotly.graph_objects as go

# ── Prepare data in Prophet format ──────────────
# Prophet requires 'ds' (date) and 'y' (value)
df_prophet = df.rename(columns={'date': 'ds', 'sales': 'y'})

# ── Build & Fit Model ────────────────────────────
model = Prophet(
    seasonality_mode='multiplicative',
    yearly_seasonality=True,
    weekly_seasonality=True,
    changepoint_prior_scale=0.05
)
model.fit(df_prophet)

# ── Forecast next 90 days ────────────────────────
future = model.make_future_dataframe(periods=90)
forecast = model.predict(future)

# ── Evaluate on test set ─────────────────────────
from sklearn.metrics import mean_absolute_error
mae = mean_absolute_error(y_test, y_pred)
print(f"Mean Absolute Error: {mae:,.0f}")

# ── Plot results ─────────────────────────────────
fig = model.plot(forecast)
fig.show()

import numpy as np
from scipy.optimize import minimize

# ── Channel configuration ───────────────────────
channels = ['email', 'paid_search', 'social', 'display', 'influencer']
total_budget = 500_000

# ── Diminishing returns model ───────────────────
# Returns = saturation_level * (1 - exp(-spend / scale))
saturation = [50000, 80000, 60000, 40000, 70000]
scale      = [80000, 120000, 100000, 60000, 150000]

def channel_returns(spend, sat, sc):
    return sat * (1 - np.exp(-spend / sc))

# ── Objective: maximize total returns ───────────
def objective(x):
    return -sum(channel_returns(x[i], saturation[i], scale[i])
                 for i in range(5))

constraints = {'type': 'eq', 'fun': lambda x: sum(x) - total_budget}
bounds = [(10_000, 300_000)] * 5
x0     = [total_budget / 5] * 5

result = minimize(objective, x0,
                   method='SLSQP',
                   bounds=bounds,
                   constraints=constraints)

for ch, spend in zip(channels, result.x):
    print(f"{ch:15}: ${spend:,.0f}")

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

# ── Create Cohort Retention Matrix ──────────────
df['cohort'] = df.groupby('user_id')['date'].transform('min').dt.to_period('M')
df['period'] = df['date'].dt.to_period('M')
df['cohort_index'] = (df['period'] - df['cohort']).apply(lambda x: x.n)

cohort_data = (df.groupby(['cohort', 'cohort_index'])['user_id']
               .nunique().reset_index())
cohort_pivot = cohort_data.pivot(index='cohort',
                                    columns='cohort_index',
                                    values='user_id')

# ── Convert to retention rates ──────────────────
retention = cohort_pivot.divide(cohort_pivot.iloc[:, 0], axis=0) * 100

# ── Heatmap ─────────────────────────────────────
plt.figure(figsize=(14, 7))
sns.heatmap(retention, annot=True, fmt='.0f',
            cmap='YlOrRd', vmin=0, vmax=100)
plt.title('Monthly Cohort Retention Rates (%)')
plt.show()

import pandas as pd
import matplotlib.pyplot as plt
from statsmodels.tsa.seasonal import STL

# ── Load time series ─────────────────────────────
df = pd.read_csv('weekly_cases.csv', parse_dates=['date'], index_col='date')

# ── Rolling averages ─────────────────────────────
df['ma7']  = df['cases'].rolling(7).mean()
df['ma30'] = df['cases'].rolling(30).mean()

# ── STL Decomposition ────────────────────────────
stl = STL(df['cases'], seasonal=13)  # 13-week seasonality
result = stl.fit()

fig, axes = plt.subplots(4, 1, figsize=(14, 10))
result.observed.plot(ax=axes[0], title='Observed')
result.trend.plot(ax=axes[1], title='Trend')
result.seasonal.plot(ax=axes[2], title='Seasonality')
result.resid.plot(ax=axes[3], title='Residual')
plt.tight_layout()
plt.show()

import yfinance as yf
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

# ── Download price data ──────────────────────────
tickers = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'JPM',
           'GS', 'JNJ', 'PFE', 'GLD', 'BND']
prices = yf.download(tickers, start='2019-01-01')['Adj Close']

# ── Daily returns & correlation ──────────────────
returns = prices.pct_change().dropna()
corr    = returns.corr()

sns.heatmap(corr, annot=True, fmt='.2f',
            cmap='RdYlGn', vmin=-1, vmax=1)
plt.title('Asset Correlation Matrix')
plt.show()

# ── Sharpe Ratio ─────────────────────────────────
mean_ret = returns.mean() * 252
std_ret  = returns.std()  * np.sqrt(252)
sharpe   = (mean_ret - 0.05) / std_ret
print(sharpe.sort_values(ascending=False))

# ── Monte Carlo Portfolio Simulation ────────────
n_sims, n_days = 1000, 252
weights    = np.ones(len(tickers)) / len(tickers)
cov_matrix = returns.cov() * 252
# ... simulate 1000 paths using Cholesky decomposition