🌟 시작하며: 왜 시뮬레이션이 필요할까?

🎯 통계 시뮬레이션이란 무엇인가?

🔬 시뮬레이션의 실제 활용 사례

🎰 몬테카를로 방법: 카지노에서 탄생한 수학

🎲 몬테카를로 방법의 기본 원리

⚙️ 몬테카를로 시뮬레이션의 단계별 프로세스

💻 실전 코딩: 파이썬으로 몬테카를로 구현하기

🎯 예제 1: 원주율(π) 계산하기

import random
import math

def monte_carlo_pi(num_samples):
    """몬테카를로 방법으로 원주율 근사하기"""
    inside_circle = 0
    
    for _ in range(num_samples):
        # -1과 1 사이의 무작위 좌표 생성
        x = random.uniform(-1, 1)
        y = random.uniform(-1, 1)
        
        # 원점으로부터의 거리 계산
        distance = math.sqrt(x**2 + y**2)
        
        # 원 안에 있는지 확인
        if distance <= 1:
            inside_circle += 1
    
    # π 근사값 계산
    pi_estimate = 4 * inside_circle / num_samples
    return pi_estimate

# 다양한 샘플 수로 실험
for n in [100, 1000, 10000, 100000, 1000000]:
    pi_approx = monte_carlo_pi(n)
    error = abs(pi_approx - math.pi)
    print(f"샘플 {n:7d}개: π ≈ {pi_approx:.6f}, 오차: {error:.6f}")

🎲 예제 2: 주사위 게임 시뮬레이션

import random

def dice_game_simulation(num_trials):
    """두 주사위 합이 7이 나올 확률 시뮬레이션"""
    success_count = 0
    
    for _ in range(num_trials):
        dice1 = random.randint(1, 6)
        dice2 = random.randint(1, 6)
        
        if dice1 + dice2 == 7:
            success_count += 1
    
    probability = success_count / num_trials
    return probability

# 시뮬레이션 실행
trials = 100000
simulated_prob = dice_game_simulation(trials)
theoretical_prob = 6/36  # 이론적 확률: (1,6), (2,5), (3,4), (4,3), (5,2), (6,1)

print(f"시뮬레이션 확률: {simulated_prob:.4f}")
print(f"이론적 확률: {theoretical_prob:.4f}")
print(f"차이: {abs(simulated_prob - theoretical_prob):.4f}")

💰 예제 3: 투자 포트폴리오 시뮬레이션

import numpy as np
import random

def portfolio_simulation(initial_investment, years, num_simulations):
    """투자 포트폴리오 몬테카를로 시뮬레이션"""
    # 연평균 수익률 7%, 표준편차 15% 가정
    mean_return = 0.07
    std_dev = 0.15
    
    final_values = []
    
    for _ in range(num_simulations):
        value = initial_investment
        
        for year in range(years):
            # 정규분포를 따르는 연간 수익률 생성
            annual_return = random.gauss(mean_return, std_dev)
            value *= (1 + annual_return)
        
        final_values.append(value)
    
    # 결과 분석
    final_values = np.array(final_values)
    
    results = {
        '평균': np.mean(final_values),
        '중앙값': np.median(final_values),
        '최소값': np.min(final_values),
        '최대값': np.max(final_values),
        '5% 백분위수': np.percentile(final_values, 5),
        '95% 백분위수': np.percentile(final_values, 95)
    }
    
    return results

# 1000만원을 10년간 투자했을 때 시뮬레이션
results = portfolio_simulation(10000000, 10, 10000)

print("=== 10년 후 포트폴리오 가치 예측 ===")
for key, value in results.items():
    print(f"{key}: {value:,.0f}원")

📊 다양한 확률 분포와 난수 생성

🎲 주요 확률 분포들

🔧 파이썬에서 다양한 분포 사용하기

import numpy as np
import random

# 1. 균등분포 (0과 1 사이)
uniform_samples = np.random.uniform(0, 1, 1000)

# 2. 정규분포 (평균 100, 표준편차 15)
normal_samples = np.random.normal(100, 15, 1000)

# 3. 지수분포 (람다 = 0.5)
exponential_samples = np.random.exponential(2, 1000)

# 4. 포아송분포 (람다 = 5)
poisson_samples = np.random.poisson(5, 1000)

# 5. 이항분포 (n=10, p=0.3)
binomial_samples = np.random.binomial(10, 0.3, 1000)

print("균등분포 평균:", np.mean(uniform_samples))
print("정규분포 평균:", np.mean(normal_samples))
print("지수분포 평균:", np.mean(exponential_samples))
print("포아송분포 평균:", np.mean(poisson_samples))
print("이항분포 평균:", np.mean(binomial_samples))

🎯 몬테카를로 방법의 장단점

✅ 장점들

❌ 단점들

🚀 고급 몬테카를로 기법들

🎯 1. 분산 감소 기법 (Variance Reduction Techniques)

⛓️ 2. 마르코프 체인 몬테카를로 (MCMC)

🎲 3. 준몬테카를로 방법 (Quasi-Monte Carlo)

🌍 실전 활용 사례: 다양한 분야에서의 몬테카를로

💰 금융 분야: 옵션 가격 결정

import numpy as np

def european_call_option_mc(S0, K, T, r, sigma, num_simulations):
    """
    몬테카를로로 유럽형 콜옵션 가격 계산
    S0: 현재 주가
    K: 행사가격
    T: 만기까지 시간(년)
    r: 무위험 이자율
    sigma: 변동성
    """
    # 만기 시점의 주가 시뮬레이션
    Z = np.random.standard_normal(num_simulations)
    ST = S0 * np.exp((r - 0.5 * sigma**2) * T + sigma * np.sqrt(T) * Z)
    
    # 옵션 수익 계산
    payoffs = np.maximum(ST - K, 0)
    
    # 현재 가치로 할인
    option_price = np.exp(-r * T) * np.mean(payoffs)
    
    # 표준오차 계산
    standard_error = np.exp(-r * T) * np.std(payoffs) / np.sqrt(num_simulations)
    
    return option_price, standard_error

# 예시: 현재가 100, 행사가 105, 1년 만기, 이자율 5%, 변동성 20%
price, se = european_call_option_mc(100, 105, 1, 0.05, 0.2, 100000)
print(f"옵션 가격: {price:.2f}원")
print(f"표준오차: {se:.4f}")

🏥 의료 분야: 질병 확산 모델링

🏭 제조업: 생산 라인 최적화

🎮 게임 개발: AI와 밸런싱

🌡️ 기후 과학: 기후 변화 예측

🛠️ 시뮬레이션 프로젝트 실전 가이드

📋 Step 1: 문제 정의 및 목표 설정

🔍 Step 2: 데이터 수집 및 분석

💻 Step 3: 모델 구현

import numpy as np
import random
from dataclasses import dataclass
from typing import List

@dataclass
class Customer:
    """고객 클래스"""
    arrival_time: float
    service_time: float
    start_service: float = 0
    end_service: float = 0
    
    def waiting_time(self):
        return self.start_service - self.arrival_time

class CafeSimulation:
    """카페 시뮬레이션 클래스"""
    
    def __init__(self, num_staff, arrival_rate, service_rate, simulation_hours):
        self.num_staff = num_staff
        self.arrival_rate = arrival_rate  # 시간당 평균 도착 고객 수
        self.service_rate = service_rate  # 시간당 평균 서비스 고객 수
        self.simulation_hours = simulation_hours
        self.customers: List[Customer] = []
        
    def generate_customers(self):
        """고객 도착 시뮬레이션"""
        current_time = 0
        while current_time < self.simulation_hours:
            # 지수분포로 다음 고객 도착 시간 생성
            inter_arrival = np.random.exponential(1/self.arrival_rate)
            current_time += inter_arrival
            
            if current_time < self.simulation_hours:
                # 서비스 시간도 지수분포로 생성
                service_time = np.random.exponential(1/self.service_rate)
                customer = Customer(current_time, service_time)
                self.customers.append(customer)
    
    def simulate_service(self):
        """서비스 프로세스 시뮬레이션"""
        # 직원별 다음 가능 시간 추적
        staff_available = [0] * self.num_staff
        
        for customer in self.customers:
            # 가장 빨리 가능한 직원 찾기
            earliest_available = min(staff_available)
            staff_idx = staff_available.index(earliest_available)
            
            # 서비스 시작 시간 결정
            customer.start_service = max(customer.arrival_time, earliest_available)
            customer.end_service = customer.start_service + customer.service_time
            
            # 직원 가능 시간 업데이트
            staff_available[staff_idx] = customer.end_service
    
    def run(self):
        """시뮬레이션 실행"""
        self.generate_customers()
        self.simulate_service()
        
        # 결과 계산
        waiting_times = [c.waiting_time() for c in self.customers]
        
        results = {
            'total_customers': len(self.customers),
            'avg_waiting_time': np.mean(waiting_times),
            'max_waiting_time': np.max(waiting_times),
            'customers_wait_over_5min': sum(1 for w in waiting_times if w > 5/60)
        }
        
        return results

# 시뮬레이션 실행
def run_multiple_simulations(num_staff, num_runs=1000):
    """여러 번 시뮬레이션 실행"""
    all_results = []
    
    for _ in range(num_runs):
        sim = CafeSimulation(
            num_staff=num_staff,
            arrival_rate=10,  # 시간당 10명
            service_rate=15,  # 시간당 15명 처리 가능
            simulation_hours=8  # 8시간 영업
        )
        results = sim.run()
        all_results.append(results)
    
    # 평균 결과 계산
    avg_results = {
        'avg_waiting_time': np.mean([r['avg_waiting_time'] for r in all_results]),
        'max_waiting_time': np.mean([r['max_waiting_time'] for r in all_results]),
        'prob_wait_over_5min': np.mean([r['customers_wait_over_5min'] / r['total_customers'] 
                                        for r in all_results])
    }
    
    return avg_results

# 다양한 직원 수로 테스트
print("=== 카페 시뮬레이션 결과 ===")
for staff in range(1, 5):
    results = run_multiple_simulations(staff)
    print(f"\n직원 {staff}명:")
    print(f"  평균 대기시간: {results['avg_waiting_time']*60:.2f}분")
    print(f"  최대 대기시간: {results['max_waiting_time']*60:.2f}분")
    print(f"  5분 이상 대기 확률: {results['prob_wait_over_5min']*100:.1f}%")

📊 Step 4: 결과 분석 및 시각화

import matplotlib.pyplot as plt

def visualize_results(staff_range, results_list):
    """결과 시각화"""
    fig, axes = plt.subplots(2, 2, figsize=(12, 10))
    
    # 평균 대기시간
    axes[0, 0].plot(staff_range, 
                    [r['avg_waiting_time']*60 for r in results_list], 
                    marker='o', linewidth=2)
    axes[0, 0].set_xlabel('직원 수')
    axes[0, 0].set_ylabel('평균 대기시간 (분)')
    axes[0, 0].set_title('직원 수에 따른 평균 대기시간')
    axes[0, 0].grid(True, alpha=0.3)
    
    # 5분 이상 대기 확률
    axes[0, 1].bar(staff_range, 
                   [r['prob_wait_over_5min']*100 for r in results_list])
    axes[0, 1].set_xlabel('직원 수')
    axes[0, 1].set_ylabel('확률 (%)')
    axes[0, 1].set_title('5분 이상 대기할 확률')
    axes[0, 1].grid(True, alpha=0.3, axis='y')
    
    plt.tight_layout()
    plt.show()

🔬 Step 5: 검증 및 민감도 분석

🎓 학습 리소스 및 도구

📚 추천 도서

🛠️ 유용한 파이썬 라이브러리

💡 온라인 학습 자료

🚀 재능넷에서 시뮬레이션 전문가 되기

💪 실력 향상을 위한 팁

🎯 마무리하며: 시뮬레이션의 미래

💭 마지막 조언

🌈 새로운 시작