Rct Data Analysis

Analysis must preserve the integrity of randomization through proper inference and transparent reporting.

import statsmodels.formula.api as smf
import pandas as pd

# Verify data structure
required = {'outcome', 'treatment', 'unit_id'}
assert required.issubset(df.columns), f"Missing columns: {required - set(df.columns)}"

# CRITICAL: Use cluster-robust or HC3-robust standard errors
if 'cluster_id' in df.columns:
    # Cluster-robust (for cluster-randomized trials)
    model = smf.ols("outcome ~ treatment", data=df).fit(
        cov_type='cluster',
        cov_kwds={'groups': df['cluster_id']}
    )
    se_type = "Cluster-robust"
else:
    # HC3-robust (for individual randomization)
    model = smf.ols("outcome ~ treatment", data=df).fit(cov_type='HC3')
    se_type = "HC3-robust"

# Extract results
itt_effect = model.params['treatment']
itt_se = model.bse['treatment']
itt_pval = model.pvalues['treatment']
ci_low, ci_high = model.conf_int().loc['treatment']

# Context for interpretation
control_mean = df[df['treatment'] == 0]['outcome'].mean()
control_sd = df[df['treatment'] == 0]['outcome'].std()
effect_size = itt_effect / control_sd

print("INTENTION-TO-TREAT (ITT) ANALYSIS")
print("=" * 60)
print(f"Outcome: {df.columns[df.columns.get_loc('outcome')]}")
print(f"N: {len(df)} ({df['treatment'].sum()} treatment, {(~df['treatment'].astype(bool)).sum()} control)")
print(f"Standard errors: {se_type}")
print(f"\nITT Effect: {itt_effect:.4f}")
print(f"Std. Error: {itt_se:.4f}")
print(f"95% CI: [{ci_low:.4f}, {ci_high:.4f}]")
print(f"p-value: {itt_pval:.4f}")
print(f"\nControl mean: {control_mean:.4f}")
print(f"Effect size: {effect_size:.3f} SD")
print(f"Relative effect: {100*itt_effect/control_mean:.1f}%")

return model,

</code_template>

</implementation_pattern>

<examples>

<example context="balance_check" difficulty="basic">
<description>Verify randomization balance before analyzing outcomes</description>
<code>
```python
@app.cell
def check_balance(df):
    # Balance checks verify randomization succeeded
    # Large imbalances may require controls or suggest implementation issues

    import pandas as pd
    import numpy as np
    from scipy import stats

    # Baseline covariates (measured before randomization)
    baseline_vars = ['age', 'education', 'income', 'baseline_outcome']

    results = []
    for var in baseline_vars:
        # Means by treatment group
        control_mean = df[df['treatment'] == 0][var].mean()
        treat_mean = df[df['treatment'] == 1][var].mean()

        # Normalized difference (Imbens & Rubin 2015)
        control_var = df[df['treatment'] == 0][var].var()
        treat_var = df[df['treatment'] == 1][var].var()
        norm_diff = (treat_mean - control_mean) / np.sqrt((control_var + treat_var) / 2)

        # T-test
        t_stat, p_val = stats.ttest_ind(
            df[df['treatment'] == 0][var].dropna(),
            df[df['treatment'] == 1][var].dropna()
        )

        results.append({
            'Variable': var,
            'Control': f"{control_mean:.3f}",
            'Treatment': f"{treat_mean:.3f}",
            'Norm Diff': f"{norm_diff:.3f}",
            'p-value': f"{p_val:.3f}"
        })

    balance_table = pd.DataFrame(results)

    print("BALANCE TABLE")
    print("=" * 60)
    print(balance_table.to_string(index=False))

    # Joint F-test
    from statsmodels.formula.api import ols
    formula = "treatment ~ " + " + ".join(baseline_vars)
    joint_model = ols(formula, data=df).fit()

    print(f"\nJoint F-test: F={joint_model.fvalue:.3f}, p={joint_model.f_pvalue:.4f}")

    # Flag concerns
    large_diffs = sum(abs(float(r['Norm Diff'])) > 0.25 for r in results)
    if large_diffs > 0:
        print(f"\nNote: {large_diffs} variables have |norm diff| > 0.25")
        print("Consider including these as controls in regression")

    return balance_table,