A/B 테스트 설계와 분석: 가설 수립부터 의사결정까지

사용자 풀 (N명)
    │
    ├─── 무작위 배정 ───┐
    │                    │
    ▼                    ▼
 대조군 (A)          실험군 (B)
 기존 UI              새 UI
    │                    │
    ▼                    ▼
 지표 측정            지표 측정
 (전환율 p_A)        (전환율 p_B)
    │                    │
    └────── 비교 ────────┘
              │
         p_B - p_A 가
        우연인가, 실재인가?

┌──────────┐   ┌──────────┐   ┌──────────┐   ┌──────────┐   ┌──────────┐
│ 1. 가설  │──▶│ 2. 지표  │──▶│ 3. 표본  │──▶│ 4. 배정  │──▶│ 5. 기간  │
│   수립   │   │   선정   │   │ 크기 결정│   │   방법   │   │   결정   │
└──────────┘   └──────────┘   └──────────┘   └──────────┘   └──────────┘

import numpy as np
from statsmodels.stats.proportion import proportion_effectsize
from statsmodels.stats.power import NormalIndPower

# 현재 전환율과 기대 전환율
p_control = 0.10       # 현재 전환율 10%
p_treatment = 0.12     # 기대 전환율 12% (MDE = 2%p)

# 효과 크기(Cohen's h) 계산
effect_size = proportion_effectsize(p_treatment, p_control)
print(f"Cohen's h: {effect_size:.4f}")
# Cohen's h: 0.0640

# 그룹당 필요 표본 수
power_analysis = NormalIndPower()
n_per_group = power_analysis.solve_power(
    effect_size=effect_size,
    alpha=0.05,
    power=0.80,
    alternative='two-sided'
)
print(f"그룹당 필요 표본 수: {n_per_group:.0f}")
print(f"총 필요 표본 수: {2 * n_per_group:.0f}")
# 그룹당 필요 표본 수: 3835
# 총 필요 표본 수: 7669

import numpy as np
from statsmodels.stats.proportion import proportion_effectsize
from statsmodels.stats.power import NormalIndPower

p_control = 0.10
mde_list = [0.005, 0.01, 0.02, 0.03, 0.05]
power_analysis = NormalIndPower()

print(f"{'MDE':>8} {'p_treatment':>12} {'Cohen h':>10} {'n/group':>10}")
print("-" * 44)
for mde in mde_list:
    p_treatment = p_control + mde
    es = proportion_effectsize(p_treatment, p_control)
    n = power_analysis.solve_power(
        effect_size=es, alpha=0.05, power=0.80, alternative='two-sided'
    )
    print(f"{mde:>8.3f} {p_treatment:>12.3f} {es:>10.4f} {n:>10.0f}")
# MDE    p_treatment    Cohen h    n/group
# --------------------------------------------
#    0.005        0.105     0.0165     57756
#    0.010        0.110     0.0326     14744
#    0.020        0.120     0.0640      3835
#    0.030        0.130     0.0942      1768
#    0.050        0.150     0.1519       680

import numpy as np
from statsmodels.stats.proportion import proportions_ztest, proportion_confint

np.random.seed(42)

# 실험 데이터 시뮬레이션
n_A, n_B = 4000, 4000
p_true_A, p_true_B = 0.100, 0.118

conversions_A = np.random.binomial(n_A, p_true_A)
conversions_B = np.random.binomial(n_B, p_true_B)
print(f"대조군: {conversions_A}/{n_A} = {conversions_A/n_A:.4f}")
print(f"실험군: {conversions_B}/{n_B} = {conversions_B/n_B:.4f}")
# 대조군: 385/4000 = 0.0963
# 실험군: 475/4000 = 0.1187

# 양측 비율 z-검정
count = np.array([conversions_A, conversions_B])
nobs = np.array([n_A, n_B])
z_stat, p_value = proportions_ztest(count, nobs, alternative='two-sided')
print(f"\nz-통계량: {z_stat:.4f}")
print(f"p-value: {p_value:.4f}")
# z-통계량: -3.2485
# p-value: 0.0012

# 각 그룹의 95% Wilson 신뢰구간
ci_A = proportion_confint(conversions_A, n_A, alpha=0.05, method='wilson')
ci_B = proportion_confint(conversions_B, n_B, alpha=0.05, method='wilson')
print(f"\n대조군 95% CI: [{ci_A[0]:.4f}, {ci_A[1]:.4f}]")
print(f"실험군 95% CI: [{ci_B[0]:.4f}, {ci_B[1]:.4f}]")
# 대조군 95% CI: [0.0875, 0.1058]
# 실험군 95% CI: [0.1091, 0.1291]

# 차이의 신뢰구간 (Wald)
p_A_hat = conversions_A / n_A
p_B_hat = conversions_B / n_B
diff = p_B_hat - p_A_hat
se_diff = np.sqrt(p_A_hat*(1-p_A_hat)/n_A + p_B_hat*(1-p_B_hat)/n_B)
ci_diff = (diff - 1.96*se_diff, diff + 1.96*se_diff)
print(f"\n전환율 차이: {diff:.4f} ({diff*100:.2f}%p)")
print(f"차이의 95% CI: [{ci_diff[0]:.4f}, {ci_diff[1]:.4f}]")
# 전환율 차이: 0.0225 (2.25%p)
# 차이의 95% CI: [0.0089, 0.0361]

import numpy as np
from scipy import stats

np.random.seed(42)

# 사용자당 매출 (로그정규분포로 시뮬레이션 — 매출 데이터의 전형적 분포)
n_A, n_B = 2000, 2000
revenue_A = np.random.lognormal(mean=3.0, sigma=1.0, size=n_A)
revenue_B = np.random.lognormal(mean=3.05, sigma=1.0, size=n_B)  # 약 5% 상승

print(f"대조군 평균 매출: ${np.mean(revenue_A):.2f} (std: ${np.std(revenue_A, ddof=1):.2f})")
print(f"실험군 평균 매출: ${np.mean(revenue_B):.2f} (std: ${np.std(revenue_B, ddof=1):.2f})")
# 대조군 평균 매출: $34.48 (std: $46.29)
# 실험군 평균 매출: $34.96 (std: $49.15)

# Welch t-검정
t_stat, p_value = stats.ttest_ind(revenue_A, revenue_B, equal_var=False)
print(f"\nt-통계량: {t_stat:.4f}")
print(f"p-value: {p_value:.4f}")
# t-통계량: -0.3167
# p-value: 0.7515

# 평균 차이의 신뢰구간
diff = np.mean(revenue_B) - np.mean(revenue_A)
se = np.sqrt(np.var(revenue_A, ddof=1)/n_A + np.var(revenue_B, ddof=1)/n_B)
ci = (diff - 1.96*se, diff + 1.96*se)
print(f"\n평균 매출 차이: ${diff:.2f}")
print(f"차이의 95% CI: [${ci[0]:.2f}, ${ci[1]:.2f}]")
# 평균 매출 차이: $0.48
# 차이의 95% CI: [$-2.48, $3.44]

import numpy as np

np.random.seed(42)

# 위와 동일한 데이터 생성
n_A, n_B = 2000, 2000
revenue_A = np.random.lognormal(mean=3.0, sigma=1.0, size=n_A)
revenue_B = np.random.lognormal(mean=3.05, sigma=1.0, size=n_B)

# 부트스트랩으로 평균 차이의 CI 추정
n_boot = 10000
boot_diffs = np.empty(n_boot)
for i in range(n_boot):
    boot_A = np.random.choice(revenue_A, size=n_A, replace=True)
    boot_B = np.random.choice(revenue_B, size=n_B, replace=True)
    boot_diffs[i] = np.mean(boot_B) - np.mean(boot_A)

ci_lower = np.percentile(boot_diffs, 2.5)
ci_upper = np.percentile(boot_diffs, 97.5)
print(f"부트스트랩 평균 차이: ${np.mean(boot_diffs):.2f}")
print(f"부트스트랩 95% CI: [${ci_lower:.2f}, ${ci_upper:.2f}]")
# 부트스트랩 평균 차이: $0.47
# 부트스트랩 95% CI: [$-2.46, $3.46]

# 부트스트랩 p-value (차이가 0 이하인 비율)
boot_p = np.mean(boot_diffs <= 0)
print(f"부트스트랩 p-value (단측): {boot_p:.4f}")
# 부트스트랩 p-value (단측): 0.3808

import numpy as np
from scipy import stats

np.random.seed(42)

# 시뮬레이션: 효과 없는 A/B 테스트에서 매일 p-value를 확인
n_per_day = 100
n_days = 50
false_positive_found = False

data_A = []
data_B = []

print("일자  |  누적 n  |  p_A    |  p_B    | p-value  | 유의?")
print("-" * 62)
for day in range(1, n_days + 1):
    # 두 그룹 모두 동일한 전환율 10% (효과 없음)
    data_A.extend(np.random.binomial(1, 0.10, n_per_day))
    data_B.extend(np.random.binomial(1, 0.10, n_per_day))

    n_curr = day * n_per_day
    p_A = np.mean(data_A)
    p_B = np.mean(data_B)

    # 풀링된 비율로 z-검정
    pooled_p = (sum(data_A) + sum(data_B)) / (2 * n_curr)
    if pooled_p == 0 or pooled_p == 1:
        continue
    se = np.sqrt(2 * pooled_p * (1 - pooled_p) / n_curr)
    z = (p_B - p_A) / se
    p_value = 2 * (1 - stats.norm.cdf(abs(z)))

    sig = "***" if p_value < 0.05 else ""
    if day <= 10 or day % 10 == 0 or p_value < 0.05:
        print(f"  {day:>3}  |  {n_curr:>5}  | {p_A:.4f} | {p_B:.4f} | {p_value:.4f}  | {sig}")
    if p_value < 0.05 and not false_positive_found:
        false_positive_found = True
        fp_day = day

if false_positive_found:
    print(f"\n=> 효과가 없는데도 {fp_day}일차에 '유의한' 결과가 나타났다!")
else:
    print(f"\n=> 50일 동안 거짓 양성이 나타나지 않았다.")

import numpy as np
from scipy import stats

np.random.seed(42)

n_simulations = 5000
n_per_day = 200
n_days = 30
check_days = [7, 14, 21, 30]  # p-value를 확인하는 시점

# 전략 1: 마지막 날만 확인
# 전략 2: 매주 확인 (4번), 하나라도 유의하면 종료
false_positive_fixed = 0
false_positive_peeking = 0

for sim in range(n_simulations):
    data_A = np.random.binomial(1, 0.10, n_per_day * n_days)
    data_B = np.random.binomial(1, 0.10, n_per_day * n_days)

    # 전략 1: 마지막 날만 확인
    n_total = n_per_day * n_days
    p_A = np.mean(data_A)
    p_B = np.mean(data_B)
    pooled = (np.sum(data_A) + np.sum(data_B)) / (2 * n_total)
    if pooled > 0 and pooled < 1:
        se = np.sqrt(2 * pooled * (1 - pooled) / n_total)
        z = (p_B - p_A) / se
        p_val = 2 * (1 - stats.norm.cdf(abs(z)))
        if p_val < 0.05:
            false_positive_fixed += 1

    # 전략 2: 매주 확인
    peeking_positive = False
    for d in check_days:
        n_curr = n_per_day * d
        p_A_d = np.mean(data_A[:n_curr])
        p_B_d = np.mean(data_B[:n_curr])
        pooled_d = (np.sum(data_A[:n_curr]) + np.sum(data_B[:n_curr])) / (2 * n_curr)
        if pooled_d > 0 and pooled_d < 1:
            se_d = np.sqrt(2 * pooled_d * (1 - pooled_d) / n_curr)
            z_d = (p_B_d - p_A_d) / se_d
            p_val_d = 2 * (1 - stats.norm.cdf(abs(z_d)))
            if p_val_d < 0.05:
                peeking_positive = True
                break
    if peeking_positive:
        false_positive_peeking += 1

fpr_fixed = false_positive_fixed / n_simulations
fpr_peeking = false_positive_peeking / n_simulations
print(f"마지막 날만 확인 — 거짓 양성률: {fpr_fixed:.4f} ({fpr_fixed*100:.1f}%)")
print(f"매주 4회 확인   — 거짓 양성률: {fpr_peeking:.4f} ({fpr_peeking*100:.1f}%)")
print(f"거짓 양성률 증가 배수: {fpr_peeking/fpr_fixed:.1f}x")
# 마지막 날만 확인 — 거짓 양성률: 0.0442 (4.4%)
# 매주 4회 확인   — 거짓 양성률: 0.1242 (12.4%)
# 거짓 양성률 증가 배수: 2.8x

import numpy as np
from scipy import stats

# O'Brien-Fleming 경계 근사 (4회 중간 분석)
n_looks = 4
alpha = 0.05

# O'Brien-Fleming: 각 분석 시점에서의 z-경계
# 정보 분율 t_k = k/K에서 경계 z_k ≈ z_{α/2} / sqrt(t_k)
z_alpha = stats.norm.ppf(1 - alpha/2)
print(f"고정 표본 임계값: z = {z_alpha:.3f} (p < {alpha})")
print(f"\nO'Brien-Fleming 경계 (4회 분석):")
print(f"{'분석 시점':>10} {'정보 분율':>10} {'z-경계':>10} {'p-경계':>12}")
print("-" * 46)
for k in range(1, n_looks + 1):
    info_frac = k / n_looks
    z_boundary = z_alpha / np.sqrt(info_frac)
    p_boundary = 2 * (1 - stats.norm.cdf(z_boundary))
    print(f"  {k}/{n_looks}차{'':<4} {info_frac:>10.2f} {z_boundary:>10.3f} {p_boundary:>12.6f}")
# 고정 표본 임계값: z = 1.960 (p < 0.05)
#
# O'Brien-Fleming 경계 (4회 분석):
#  분석 시점  정보 분율      z-경계       p-경계
# ----------------------------------------------
#   1/4차          0.25      3.920     0.000089
#   2/4차          0.50      2.772     0.005575
#   3/4차          0.75      2.263     0.023625
#   4/4차          1.00      1.960     0.050000