오차막대 그림¶

import numpy as np
import matplotlib.pyplot as plt

rng = np.random.default_rng(42)

# 네 집단. 표본 크기만 10, 30, 100, 300으로 다르다.
# 모집단의 표준편차는 모두 3으로 같게 두었다.
gs = ['A', 'B', 'C', 'D']
data = {g: rng.normal(m, s, n_) for g, m, s, n_ in
        zip(gs, [10, 12, 11, 13], [3, 3, 3, 3], [10, 30, 100, 300])}

means = np.array([data[g].mean() for g in gs])
sds   = np.array([data[g].std(ddof=1) for g in gs])   # 표본표준편차 (ddof=1)
ns    = np.array([len(data[g]) for g in gs])

ses = sds / np.sqrt(ns)     # 표준오차 = SD / sqrt(n)
cis = 1.96 * ses            # 95% 신뢰구간의 반폭 (정규근사)

fig, axes = plt.subplots(1, 3, figsize=(13, 3.8), sharey=True)

# 같은 평균, 같은 자료. 오차막대의 정의만 바꾼다.
for ax, err, name in zip(axes, [sds, ses, cis], ["±1 SD", "±1 SE", "95% CI"]):
    # yerr에 준 값만큼 위아래로 막대가 뻗는다. capsize는 끝의 가로선 길이
    ax.errorbar(gs, means, yerr=err, fmt='o', capsize=5, color='steelblue', ms=7)
    ax.set_title(f"Error bars = {name}")
    ax.spines[['top', 'right']].set_visible(False)

axes[0].set_ylabel("Mean")
plt.tight_layout()
plt.show()

for g, m, s, e, c, nn in zip(gs, means, sds, ses, cis, ns):
    print(f"  {g}: n={nn:3d}  mean={m:5.2f}  SD={s:4.2f}  SE={e:4.2f}  95%CI=±{c:4.2f}")

  A: n= 10  mean= 8.99  SD=2.80  SE=0.89  95%CI=±1.74
  B: n= 30  mean=12.49  SD=2.29  SE=0.42  95%CI=±0.82
  C: n=100  mean=10.82  SD=2.60  SE=0.26  95%CI=±0.51
  D: n=300  mean=12.94  SD=3.00  SE=0.17  95%CI=±0.34

import numpy as np
from scipy import stats

rng = np.random.default_rng(0)
n, B = 30, 100_000

def rates(z):
    a, b = rng.normal(0, 1, (B, n)), rng.normal(0, 1, (B, n))
    sa = a.std(1, ddof=1) / np.sqrt(n)
    sb = b.std(1, ddof=1) / np.sqrt(n)
    non_overlap = np.abs(a.mean(1) - b.mean(1)) > z * (sa + sb)
    t_test = stats.ttest_ind(a, b, axis=1)[1] < 0.05
    return non_overlap.mean(), t_test.mean()

print("참 차이가 0 일 때 (1종 오류율, 목표 0.05)")
for z, label in [(1.96, "95% CI"), (1.0, "±1 SE"), (1.386, "83.4% CI")]:
    no, tt = rates(z)
    print(f"  {label:>9} 비겹침 {no:.4f}     t 검정 {tt:.4f}")

참 차이가 0 일 때 (1종 오류율, 목표 0.05)
     95% CI 비겹침 0.0078     t 검정 0.0499
      ±1 SE 비겹침 0.1645     t 검정 0.0496
   83.4% CI 비겹침 0.0559     t 검정 0.0500

import numpy as np
from scipy import stats

rng = np.random.default_rng(0)
n, B, d = 30, 100_000, 0.8
a, b = rng.normal(0, 1, (B, n)), rng.normal(d, 1, (B, n))
sa = a.std(1, ddof=1) / np.sqrt(n)
sb = b.std(1, ddof=1) / np.sqrt(n)
diff = np.abs(a.mean(1) - b.mean(1))

print(f"참 차이 {d} 일 때의 탐지율")
print(f"  95% CI 비겹침    {np.mean(diff > 1.96 * (sa + sb)):.4f}")
print(f"  83.4% CI 비겹침  {np.mean(diff > 1.386 * (sa + sb)):.4f}")
print(f"  t 검정           {np.mean(stats.ttest_ind(a, b, axis=1)[1] < 0.05):.4f}")

참 차이 0.8 일 때의 탐지율
  95% CI 비겹침    0.6318
  83.4% CI 비겹침  0.8722
  t 검정           0.8614

import numpy as np
import matplotlib.pyplot as plt
from scipy import stats

plt.rcParams["font.family"] = "Apple SD Gothic Neo"   # 한글 글꼴
plt.rcParams["axes.unicode_minus"] = False            # 음수 기호가 네모가 되지 않게

rng = np.random.default_rng(3)
n = 25
subject = rng.normal(0, 5, n)                 # 개인차가 크다
before = 50 + subject + rng.normal(0, 1, n)
after = before + 1.5 + rng.normal(0, 1, n)    # 참 효과 1.5

d = after - before
ci_before = 1.96 * before.std(ddof=1) / np.sqrt(n)
ci_after = 1.96 * after.std(ddof=1) / np.sqrt(n)
ci_diff = 1.96 * d.std(ddof=1) / np.sqrt(n)

print(f"전  평균 {before.mean():.3f} ± {ci_before:.3f}")
print(f"후  평균 {after.mean():.3f} ± {ci_after:.3f}")
print(f"  → 두 구간이 겹치는가: {before.mean() + ci_before > after.mean() - ci_after}")
print(f"\n차이 평균 {d.mean():.3f} ± {ci_diff:.3f}   0 을 포함하는가: "
      f"{d.mean() - ci_diff < 0 < d.mean() + ci_diff}")
print(f"대응표본 t 검정 p = {stats.ttest_rel(after, before)[1]:.6f}")

fig, axes = plt.subplots(1, 3, figsize=(13, 3.8))
axes[0].errorbar([0, 1], [before.mean(), after.mean()],
                 yerr=[ci_before, ci_after], fmt='o', capsize=5)
axes[0].set_xticks([0, 1]); axes[0].set_xticklabels(["전", "후"])
axes[0].set_title("집단 평균 ± 95% CI\n— 겹친다", fontsize=9)

for i in range(n):
    axes[1].plot([0, 1], [before[i], after[i]], color="gray", lw=0.7, alpha=0.7)
axes[1].set_xticks([0, 1]); axes[1].set_xticklabels(["전", "후"])
axes[1].set_title("개인별 연결선\n— 거의 모두 올랐다", fontsize=9)

axes[2].errorbar([0], [d.mean()], yerr=[ci_diff], fmt='o', capsize=5, color="C3")
axes[2].axhline(0, color="black", lw=0.8)
axes[2].set_xlim(-0.5, 0.5); axes[2].set_xticks([])
axes[2].set_title("차이의 95% CI\n— 0 을 포함하지 않는다", fontsize=9)
fig.tight_layout()
plt.show()

전  평균 49.854 ± 2.366
후  평균 51.071 ± 2.448
  → 두 구간이 겹치는가: True

차이 평균 1.216 ± 0.421   0 을 포함하는가: False
대응표본 t 검정 p = 0.000008

import numpy as np

rng = np.random.default_rng(1)

def wald(k, n, z=1.96):
    p = k / n
    h = z * np.sqrt(p * (1 - p) / n)
    return p - h, p + h

def wilson(k, n, z=1.96):
    p = k / n
    d = 1 + z * z / n
    center = (p + z * z / (2 * n)) / d
    h = z / d * np.sqrt(p * (1 - p) / n + z * z / (4 * n * n))
    return center - h, center + h

print("95% 구간의 실제 포함률")
print(f"{'n':>5}{'p':>7}{'왈드':>10}{'윌슨':>10}")
for n in (20, 50, 200):
    for p in (0.05, 0.20, 0.50):
        k = rng.binomial(n, p, 40_000)
        lo, hi = wald(k, n)
        lo2, hi2 = wilson(k, n)
        print(f"{n:>5}{p:>7.2f}{np.mean((lo <= p) & (p <= hi)):>10.4f}"
              f"{np.mean((lo2 <= p) & (p <= hi2)):>10.4f}")

print("\n관측된 성공이 0 건일 때")
for n in (20, 100):
    print(f"  n={n}: 왈드 {wald(0, n)}  ← 폭이 0")
    print(f"        윌슨 {tuple(round(v, 4) for v in wilson(0, n))}")

95% 구간의 실제 포함률
    n      p        왈드        윌슨
   20   0.05    0.6384    0.9245
   20   0.20    0.9218    0.9556
   20   0.50    0.9585    0.9585
   50   0.05    0.9219    0.9623
   50   0.20    0.9377    0.9511
   50   0.50    0.9339    0.9339
  200   0.05    0.9274    0.9682
  200   0.20    0.9420    0.9586
  200   0.50    0.9436    0.9436

관측된 성공이 0 건일 때
  n=20: 왈드 (0.0, 0.0)  ← 폭이 0
        윌슨 (-0.0, 0.1611)
  n=100: 왈드 (0.0, 0.0)  ← 폭이 0
        윌슨 (0.0, 0.037)

import numpy as np
import matplotlib.pyplot as plt

plt.rcParams["font.family"] = "Apple SD Gothic Neo"   # 한글 글꼴
plt.rcParams["axes.unicode_minus"] = False            # 음수 기호가 네모가 되지 않게

rng = np.random.default_rng(5)
n = 40
a = rng.lognormal(0, 0.6, n)
b = rng.lognormal(0.5, 0.6, n)
ratio = b.mean() / a.mean()

# 로그 척도에서 구간을 만들고 되돌린다
log_r = np.log(b) .mean() - np.log(a).mean()
se_log = np.sqrt(np.log(b).var(ddof=1) / n + np.log(a).var(ddof=1) / n)
lo, hi = np.exp(log_r - 1.96 * se_log), np.exp(log_r + 1.96 * se_log)

print(f"기하평균 비 {np.exp(log_r):.4f}")
print(f"  로그 척도 구간   [{log_r - 1.96 * se_log:+.4f}, {log_r + 1.96 * se_log:+.4f}]  (대칭)")
print(f"  되돌린 구간      [{lo:.4f}, {hi:.4f}]")
print(f"  중심으로부터     -{np.exp(log_r) - lo:.4f} / +{hi - np.exp(log_r):.4f}  (비대칭)")
print(f"\n대칭 막대를 억지로 쓰면 아래쪽 끝이 {np.exp(log_r) - (hi - np.exp(log_r)):.4f}")

fig, axes = plt.subplots(1, 2, figsize=(10, 3.8))
axes[0].errorbar([0], [np.exp(log_r)],
                 yerr=[[np.exp(log_r) - lo], [hi - np.exp(log_r)]],
                 fmt='o', capsize=6)
axes[0].axhline(1, color="red", ls="--", lw=1)
axes[0].set_xlim(-0.5, 0.5); axes[0].set_xticks([])
axes[0].set_title("선형 축 — 막대가 비대칭", fontsize=9)

axes[1].errorbar([0], [np.exp(log_r)],
                 yerr=[[np.exp(log_r) - lo], [hi - np.exp(log_r)]],
                 fmt='o', capsize=6)
axes[1].set_yscale("log")
axes[1].axhline(1, color="red", ls="--", lw=1)
axes[1].set_xlim(-0.5, 0.5); axes[1].set_xticks([])
axes[1].set_title("로그 축 — 막대가 대칭이 된다", fontsize=9)
fig.tight_layout()
plt.show()

기하평균 비 1.9830
  로그 척도 구간   [+0.4468, +0.9225]  (대칭)
  되돌린 구간      [1.5632, 2.5155]
  중심으로부터     -0.4198 / +0.5325  (비대칭)

대칭 막대를 억지로 쓰면 아래쪽 끝이 1.4505

import numpy as np
import matplotlib.pyplot as plt

plt.rcParams["font.family"] = "Apple SD Gothic Neo"   # 한글 글꼴
plt.rcParams["axes.unicode_minus"] = False            # 음수 기호가 네모가 되지 않게

rng = np.random.default_rng(7)
groups = ["A", "B", "C"]
data = [rng.normal(m, 2.5, 30) for m in (10, 11, 10.5)]
means = np.array([d.mean() for d in data])
ses = np.array([d.std(ddof=1) / np.sqrt(len(d)) for d in data])

for g, m, s in zip(groups, means, ses):
    print(f"  {g}: 평균 {m:.3f}   SE {s:.3f}   95% CI [{m - 1.96*s:.3f}, {m + 1.96*s:.3f}]")

fig, axes = plt.subplots(1, 3, figsize=(13, 3.8))
axes[0].bar(groups, means, yerr=1.96 * ses, capsize=6)
axes[0].set_title("막대 + 오차막대\n— 막대 안이 '확실'해 보인다", fontsize=9)

axes[1].errorbar(groups, means, yerr=1.96 * ses, fmt='o', capsize=6)
axes[1].set_ylim(8.5, 12.5)
axes[1].set_title("점 + 오차막대\n— 구간만 보인다", fontsize=9)

for i, d in enumerate(data):
    axes[2].scatter(np.full(len(d), i) + rng.normal(0, 0.06, len(d)), d, s=8, alpha=0.4)
axes[2].errorbar(range(3), means, yerr=1.96 * ses, fmt='o', capsize=6, color="C3", zorder=5)
axes[2].set_xticks(range(3)); axes[2].set_xticklabels(groups)
axes[2].set_title("원자료 + 구간\n— 가장 정직하다", fontsize=9)
fig.tight_layout()
plt.show()

  A: 평균 8.965   SE 0.382   95% CI [8.217, 9.713]
  B: 평균 10.988   SE 0.414   95% CI [10.177, 11.800]
  C: 평균 10.333   SE 0.373   95% CI [9.602, 11.065]

import numpy as np
from scipy import stats

rng = np.random.default_rng(2)
n, B = 20, 20_000

print("참 평균이 모두 같은 K개 집단에서, 개별 95% CI 를 쓸 때")
print(f"{'K':>5}{'적어도 하나가 참값을 놓칠 확률':>32}{'본페로니 보정 후':>18}")
for K in (1, 3, 5, 10, 20):
    miss = miss_b = 0
    for _ in range(B):
        x = rng.normal(0, 1, (K, n))
        m = x.mean(1)
        se = x.std(1, ddof=1) / np.sqrt(n)
        t_ind = stats.t.ppf(0.975, n - 1)
        t_bon = stats.t.ppf(1 - 0.025 / K, n - 1)
        if np.any(np.abs(m) > t_ind * se):
            miss += 1
        if np.any(np.abs(m) > t_bon * se):
            miss_b += 1
    print(f"{K:>5}{miss / B:>32.4f}{miss_b / B:>18.4f}")

참 평균이 모두 같은 K개 집단에서, 개별 95% CI 를 쓸 때
    K               적어도 하나가 참값을 놓칠 확률         본페로니 보정 후
    1                          0.0518            0.0518
    3                          0.1436            0.0486
    5                          0.2265            0.0491
   10                          0.3987            0.0507
   20                          0.6414            0.0491

import numpy as np

rng = np.random.default_rng(1)

def notch(x):
    q1, q3 = np.percentile(x, [25, 75])
    h = 1.57 * (q3 - q1) / np.sqrt(len(x))
    return np.median(x) - h, np.median(x) + h

print("(1) 노치가 참 중앙값을 포함하는 비율  (광고 0.95)")
for n in (20, 50, 200, 1000):
    c = sum(1 for _ in range(20_000)
            if (lambda lo, hi: lo <= 0 <= hi)(*notch(rng.normal(0, 1, n))))
    print(f"  n={n:>5}: {c / 20_000:.4f}")

print("\n(2) 두 집단의 참 중앙값이 같을 때 노치가 겹치지 않을 확률  (목표 0.05)")
for n in (20, 50, 200, 1000):
    c = 0
    for _ in range(20_000):
        a, b = notch(rng.normal(0, 1, n)), notch(rng.normal(0, 1, n))
        if a[1] < b[0] or b[1] < a[0]:
            c += 1
    print(f"  n={n:>5}: {c / 20_000:.4f}")

(1) 노치가 참 중앙값을 포함하는 비율  (광고 0.95)
  n=   20: 0.8777
  n=   50: 0.8953
  n=  200: 0.9037
  n= 1000: 0.9033

(2) 두 집단의 참 중앙값이 같을 때 노치가 겹치지 않을 확률  (목표 0.05)
  n=   20: 0.0290
  n=   50: 0.0225
  n=  200: 0.0178
  n= 1000: 0.0158