
from typing import Tuple
import math

def normal_approximation_to_binomial(n: int, p: float) -> Tuple[float, float]:
    """
    X ~ B(n,p)이고 n이 충분히 클 때,
    평균값 mu와 표준편차 sigma 계산 
    """
    mu = p * n
    sigma = math.sqrt(p * (1 - p) * n)
    return mu, sigma


mu_0, sigma_0 = normal_approximation_to_binomial(1000, 0.5)
print(f"평균:\t{mu_0}")
print(f"표준편차:\t{sigma_0:.1f}")

평균:	500.0
표준편차:	15.8


import os
import sys
sys.path.insert(0, os.path.abspath('..'))


from scratch.probability import normal_cdf

normal_probability_below = normal_cdf

def normal_probability_above(lo: float,
                             mu: float = 0,
                             sigma: float = 1) -> float:
    return 1 - normal_cdf(lo, mu, sigma)

def normal_probability_between(lo: float,
                               hi: float,
                               mu: float = 0,
                               sigma: float = 1) -> float:
    return normal_cdf(hi, mu, sigma) - normal_cdf(lo, mu, sigma)

def normal_probability_outside(lo: float,
                               hi: float,
                               mu: float = 0,
                               sigma: float = 1) -> float:
    return 1 - normal_probability_between(lo, hi, mu, sigma)

<Figure size 432x288 with 0 Axes>


from scratch.probability import inverse_normal_cdf

def normal_upper_bound(probability: float,
                       mu: float = 0,
                       sigma: float = 1) -> float:
    return inverse_normal_cdf(probability, mu, sigma)

def normal_lower_bound(probability: float,
                       mu: float = 0,
                       sigma: float = 1) -> float:
    return inverse_normal_cdf(1 - probability, mu, sigma)

def normal_two_sided_bounds(probability: float,
                            mu: float = 0,
                            sigma: float = 1) -> Tuple[float, float]:
    tail_probability = (1 - probability) / 2

    upper_bound = normal_lower_bound(tail_probability, mu, sigma)

    lower_bound = normal_upper_bound(tail_probability, mu, sigma)

    return lower_bound, upper_bound


from math import ceil, floor

lo, hi = normal_two_sided_bounds(0.95, mu_0, sigma_0)

print(f"하단기각역: {floor(lo)} 이하")
print(f"상단기각역: {ceil(hi)} 이상")

하단기각역: 469 이하
상단기각역: 531 이상


mu_1, sigma_1 = normal_approximation_to_binomial(1000, 0.55)
print(f"p=0.55일 때 평균(mu_1):\t\t {mu_1}")
print(f"p=0.55일 때 표준편차(sigma_1):\t {sigma_1}")

p=0.55일 때 평균(mu_1):		 550.0
p=0.55일 때 표준편차(sigma_1):	 15.732132722552274


type_2_probability = normal_probability_between(lo, hi, mu_1, sigma_1)
print(f"{type_2_probability:.3f}")

0.113


power = 1 - type_2_probability
print(f"{power:.3f}")

0.887


hi = normal_upper_bound(0.95, mu_0, sigma_0)
print(f"hi 값: {hi:.3f}")

hi 값: 526.007


type_2_probability = normal_probability_below(hi, mu_1, sigma_1)
print(f"{type_2_probability:.3f}")

0.064


power = 1 - type_2_probability 
print(f"{power:.3f}")

0.936


def two_sided_p_value(x: float, 
                      mu: float = 0, 
                      sigma: float = 1) -> float:
    if x >= mu:
        return 2 * normal_probability_above(x, mu, sigma)
    else:
        return 2 * normal_probability_below(x, mu, sigma)


two_sided_p_value(529.5, mu_0, sigma_0)

0.06207721579598835


import random

# 실행할 때 마다 동일한 결과를 얻기 위해 seed 지정
random.seed(1000)

# 동전을 1000번 던져서 앞면이 530회 이상 또는 470회 이하로 나오는 경우 기억하기
extreme_value_count = 0

# '동전 1000번 던지기'를 1만번 반복하기
# 반복할 때마다 앞면이 나오는 횟수를 센다. 
for _ in range(10000):
    num_heads = sum(1 if random.random() < 0.5 else 0 for _ in range(1000))
    if num_heads >= 530 or num_heads <= 470:         
        extreme_value_count += 1                     

# 최종 확률
extreme_value_count / 10000

0.0617


# 연속성 보정에 주의할 것.
two_sided_p_value(531.5, mu_0, sigma_0)

0.046345287837786575


upper_p_value = normal_probability_above
lower_p_value = normal_probability_below


print("525회 이상에 대한 p-값:", "{:.3f}".format(upper_p_value(524.5, mu_0, sigma_0)))
print("527회 이상에 대한 p-값:", "{:.3f}".format(upper_p_value(526.5, mu_0, sigma_0)))

525회 이상에 대한 p-값: 0.061
527회 이상에 대한 p-값: 0.047


p_hat = 525 / 1000
mu = p_hat
sigma = math.sqrt(p_hat * (1 - p_hat) / 1000)

print(f"평균:\t{mu}")
print(f"표준편차:\t{sigma:.3f}")

평균:	0.525
표준편차:	0.016


lo, hi = normal_two_sided_bounds(0.95, mu, sigma)

print(f"신뢰구간:\t({lo:.3f}, {hi:.3f})")

신뢰구간:	(0.494, 0.556)


p_hat = 540 / 1000
mu = p_hat
sigma = math.sqrt(p_hat * (1 - p_hat) / 1000)
lo, hi = normal_two_sided_bounds(0.95, mu, sigma)

print(f"평균:\t{mu}")
print(f"표준편차:\t{sigma:.3f}")
print(f"신뢰구간:\t({lo:.3f}, {hi:.3f})")

평균:	0.54
표준편차:	0.016
신뢰구간:	(0.509, 0.571)


from typing import List

# 주사위 1,000 번 던진 결과 저장
# [0, 1) 사이의 값을 무작위로 생성하여, 0.5 이하면 뒷면, 0.5 이상이면 앞면으로 처리
def run_experiment() -> List[bool]:
    return [random.random() < 0.5 for _ in range(1000)]

# 동전 1000번 던지기 결과에 대해
# 유의수준 5%의 기각역에 포함되는 사건인지 여부 확인
def reject_fairness(experiment: List[bool]) -> bool:
    """Using the 5% significance levels"""
    num_heads = len([flip for flip in experiment if flip])
    return num_heads < 469 or num_heads > 531


random.seed(0)
experiments = [run_experiment() for _ in range(1000)]
num_rejections = len([experiment
                      for experiment in experiments
                      if reject_fairness(experiment)])

print(f"유의수준 5%의 기각역에 포함될 확률: {num_rejections/1000}")

유의수준 5%의 기각역에 포함될 확률: 0.046


def estimated_parameters(N: int, n: int) -> Tuple[float, float]:
    p = n / N
    sigma = math.sqrt(p * (1 - p) / N)
    return p, sigma

def a_b_test_statistic(N_A: int, n_A: int, N_B: int, n_B: int) -> float:
    p_A, sigma_A = estimated_parameters(N_A, n_A)
    p_B, sigma_B = estimated_parameters(N_B, n_B)
    return (p_B - p_A) / math.sqrt(sigma_A ** 2 + sigma_B ** 2)

z = a_b_test_statistic(1000, 200, 1000, 180)
print(f"(p_B - p_A)를 표준화한 값: {z:.2f}")

(p_B - p_A)를 표준화한 값: -1.14


# 표준정규분포에서 -1.14에 대한 p-값
two_sided_p_value(z)

0.2541419765422359


z = a_b_test_statistic(1000, 200, 1000, 150)
print(z)

-2.948839123097944


two_sided_p_value(z)

0.003189699706216853


def B(alpha: float, beta: float) -> float:
    """A normalizing constant so that the total probability is 1"""
    return math.gamma(alpha) * math.gamma(beta) / math.gamma(alpha + beta)

def beta_pdf(x: float, alpha: float, beta: float) -> float:
    if x <= 0 or x >= 1:          # no weight outside of [0, 1]
        return 0
    return x ** (alpha - 1) * (1 - x) ** (beta - 1) / B(alpha, beta)


from matplotlib import pyplot as plt

xs = [x / 100.0 for x in range(0,100)]
plt.plot(xs,[beta_pdf(x,alpha=1,beta=1) for x in xs],'-',label='Beta(1,1)')
plt.plot(xs,[beta_pdf(x,alpha=10,beta=10) for x in xs],'-.',label='Beta(10,10)')
plt.plot(xs,[beta_pdf(x,alpha=4,beta=16) for x in xs],'--',label='Beta(4, 16)')
plt.plot(xs,[beta_pdf(x,alpha=16,beta=4) for x in xs],':',label='Beta(16,4)')
plt.legend()
plt.title('Beta pdfs')
plt.show()


from matplotlib import pyplot as plt

xs = [x / 100.0 for x in range(0,100)]
plt.plot(xs,[beta_pdf(x,alpha=1,beta=1) for x in xs],'-',label='Beta(1,1)')
plt.plot(xs,[beta_pdf(x,alpha=55,beta=45) for x in xs],'--',label='Beta(55,45)')
plt.plot(xs,[beta_pdf(x,alpha=50,beta=50) for x in xs],':',label='Beta(50, 50)')
plt.legend()
plt.title('Beta pdfs')
plt.show()


from matplotlib import pyplot as plt

xs = [x / 100.0 for x in range(0,100)]
plt.plot(xs,[beta_pdf(x,alpha=21,beta=31) for x in xs],'-',label='Beta(21,31)')
plt.plot(xs,[beta_pdf(x,alpha=75,beta=75) for x in xs],'--',label='Beta(75,75)')
plt.plot(xs,[beta_pdf(x,alpha=70,beta=80) for x in xs],':',label='Beta(70,80)')
plt.legend()
plt.title('Beta pdfs')
plt.show()


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

x = np.linspace(0, 1, 100)

alpha_0, beta_0 = 50, 50


rv = beta(alpha_0, beta_0)
plt.plot(x, rv.pdf(x), 'b-', label='beta(50,50)')
plt.plot([0.5, 0.5], [0,0.5], 'r:', label='mean=0.5')
plt.legend(loc='best')
plt.show()


alpha_1, beta_1 = 70, 80


rv = beta(alpha_1, beta_1)
plt.plot(x, rv.pdf(x), 'b-', label='beta(70,80)')
plt.plot([7/15, 7/15], [0,0.5], 'r:', label='mean=0.47')
plt.legend(loc='best')
plt.show()


rv.cdf(0.51) - rv.cdf(0.49)

0.1390108141365065


양측검정	상단측검정	하단측검정

가설과 추론¶

통계적 가설검정¶

귀무가설과 대립가설¶

주요 예제: 동전 던지기¶

이항분포와 정규분포¶

주의사항¶

정규분포 관련 함수 정리¶

주의사항¶

통계적 가설검정¶

귀무가설과 대립가설¶

유의수준¶

양측검정/단측검정¶

기각역과 가설검정¶

동전 던지기 양측검정¶

동전 던지기 양측검정과 검정력¶

동전 던지기 상단측검정¶

연습문제¶

$p$-값과 가설검정¶

$p$-값과 양측검정¶

예제¶

연속성 보정¶

모의실험으로 확인하기¶

$p$-값과 단측검정¶

신뢰구간¶

신뢰구간과 가설검정¶

신뢰수준과 유의수준¶

$p$-해킹, 세상 일이 원래 그렇다!¶

모의실험: $p$-해킹¶

A/B 테스트¶

예제: 광고 성공률 A/B 테스트¶

광고 성공률 확률분포¶

광고 성공률 차이의 가설검정¶

광고 성공률 차이의 확률분포¶

참조: 정규분포의 연산¶

성공률 차이 귀무가설¶

성공률 차이 가설검정¶

경우 1¶

경우 2¶

베이지안 추론¶

베타분포와 이항분포¶

베타분포 활용¶

사전분포¶

사후분포¶

베이지안 추론 특징¶

사이파이 통계 모듈 활용¶

beta 클래스 활용¶

주의사항¶

`beta` 클래스 활용¶