Metrics, Guardrails, and Evaluation Criteria Questions

import numpy as np
from typing import Tuple

def compute_ate_with_bootstrap(treatment: np.ndarray,
                               outcome: np.ndarray,
                               n_bootstrap: int = 1000,
                               random_state: int = None) -> Tuple[float, float, float]:
    """
    Returns (ate, ci_lower, ci_upper) where ate is E[Y|T=1]-E[Y|T=0]
    and ci_* are the 95% bootstrap percentile interval bounds.
    Assumes treatment is 0/1 and treatment/outcome are same length.
    """
    if treatment.shape[0] != outcome.shape[0]:
        raise ValueError("treatment and outcome must have same length")
    n = treatment.shape[0]
    if n == 0:
        raise ValueError("Empty inputs")
    if not np.isin(treatment, [0, 1]).all():
        raise ValueError("treatment must be binary 0/1")
    
    rng = np.random.default_rng(random_state)
    treated_mask = treatment == 1
    control_mask = ~treated_mask
    if treated_mask.sum() == 0 or control_mask.sum() == 0:
        raise ValueError("Need at least one treated and one control unit")
    
    def ate_from_arrays(t, y):
        # difference in means (handles binary or continuous y)
        return y[t == 1].mean() - y[t == 0].mean()
    
    ate = ate_from_arrays(treatment, outcome)
    
    boot_ates = np.empty(n_bootstrap)
    indices = np.arange(n)
    for i in range(n_bootstrap):
        samp_idx = rng.choice(indices, size=n, replace=True)
        boot_ates[i] = ate_from_arrays(treatment[samp_idx], outcome[samp_idx])
    
    ci_lower, ci_upper = np.percentile(boot_ates, [2.5, 97.5])
    return float(ate), float(ci_lower), float(ci_upper)