안녕하세요, 저는 HolySheep AI 기술 블로그의 개발자입니다. 이번 튜토리얼에서는 암호화폐期权 데이터를 다루는 방법을 처음부터 알려드리겠습니다. Deribit에서历史期权 데이터를 Tardis로 다운로드하고, 실제波动率을 계산하며, HolySheep AI로 분석 결과를 자동으로 요약하는 완전한 워크플로우를 다루겠습니다.

⚠️ 스크린샷 힌트: 이 튜토리얼의 모든 코드는 Python 3.9+ 환경에서 테스트되었습니다. VS Code나 Jupyter Notebook에서 따라하면 됩니다.

Deribit期权データとは？

Deribit는 세계 최대의加密货币期权 거래소입니다. Bitcoin과 Ethereum의期权(옵션)을 거래할 수 있으며, 기관투자자들과 개인トレーダー들이 변동성 거래, 헤지, 수익률 극대화를 위해 활용합니다.

Deribit의期权データ有什么用？

왜 Tardis Machine이 필요한가

Deribit는直接的으로大量の历史데이터를 제공하지 않습니다. Tardis Machine(tardis.dev)은:

Tardis Machine 가입 및 API 키 발급

단계 1: Tardis Machine 공식 웹사이트에 접속합니다.

단계 2: 우측 상단의 "Sign Up" 버튼을 클릭합니다. 이메일과 비밀번호로 가입할 수 있으며, Github 계정으로도 가입 가능합니다.

단계 3: 대시보드에서 "API Keys" 메뉴로 이동하여 새 API 키를 생성합니다. 키 이름은 자유롭게 입력하면 됩니다.

💡 팁: 무료 플랜으로 Deribit의 1분봉(OHLC) 데이터를 최근 30일까지 다운로드할 수 있습니다. 더 오래된 데이터나 분단위 이하의 데이터가 필요하면 유료 플랜(월 $29~)으로 업그레이드하세요.

Python 환경 준비

먼저 필요한 라이브러리를 설치합니다.

# 필요한 라이브러리 설치
pip install tardis-machine pandas numpy requests python-dotenv scipy matplotlib


HolySheep AI SDK 설치

pip install openai

Deribit期权历史데이터 다운로드

방법 1: Tardis REST API直接ダウンロード

가장 간단한 방법은 Tardis의 REST API를 사용하여 Python으로直接データ请求하는 것입니다.

import requests
import pandas as pd
from datetime import datetime, timedelta
import time


======== 설정값 ========

TARDIS_API_KEY = "YOUR_TARDIS_API_KEY"  # Tardis에서 발급받은 키
TARDIS_BASE_URL = "https://api.tardis.dev/v1"


Deribit BTC期权（満期日 2024-06-28）

EXCHANGE = "deribit"
INSTRUMENT = "BTC-28JUN24-65000-P"  # PUT 옵션 예시
START_DATE = "2024-06-01"
END_DATE = "2024-06-28"


======== APIリクエスト関数 ========

def download_deribit_candles(instrument, start_date, end_date, interval="1"):
    """
    Tardis Machine에서 Deribit期权 OHLC数据下载
    
    Parameters:
        instrument: 옵션 심볼 (예: BTC-28JUN24-65000-P)
        start_date: 시작일 (YYYY-MM-DD)
        end_date: 종료일 (YYYY-MM-DD)
        interval: 캔들 간격 (1=1분, 60=1시간)
    
    Returns:
        pandas.DataFrame: OHLCV 데이터
    """
    url = f"{TARDIS_BASE_URL}/download/{exchange}/{instrument}.csv"
    
    params = {
        "apiKey": TARDIS_API_KEY,
        "from": f"{start_date}T00:00:00",
        "to": f"{end_date}T23:59:59",
        "interval": interval,
        "format": "ohlcv",
    }
    
    print(f"📥 데이터 다운로드 중: {instrument}")
    print(f"   기간: {start_date} ~ {end_date}")
    
    response = requests.get(url, params=params, timeout=60)
    
    if response.status_code == 200:
        # CSV 데이터를 pandas DataFrame으로 변환
        from io import StringIO
        df = pd.read_csv(StringIO(response.text))
        print(f"✅ 다운로드 완료: {len(df)}건의 데이터")
        return df
    else:
        print(f"❌ 오류 발생: {response.status_code}")
        print(f"   메시지: {response.text}")
        return None


======== 메인 실행 ========

df_ohlcv = download_deribit_candles(
    instrument=INSTRUMENT,
    start_date=START_DATE,
    end_date=END_DATE,
    interval="1"  # 1분봉
)

if df_ohlcv is not None:
    print("\n데이터 미리보기:")
    print(df_ohlcv.head(10))
    print(f"\n데이터 기간: {df_ohlcv['timestamp'].min()} ~ {df_ohlcv['timestamp'].max()}")

방법 2: Tardis WebSocket 실시간 스트림

실시간 데이터를 처리해야 하거나, 더精细的な BOOK数据이 필요한 경우 WebSocket 스트림을 사용합니다.

import asyncio
import json
from tardis_client import TardisClient,天庆
import pandas as pd
from datetime import datetime


======== 설정값 ========

TARDIS_API_KEY = "YOUR_TARDIS_API_KEY"

async def stream_deribit_options():
    """
    Tardis WebSocket을 통해 Deribit BTC期权 실시간 데이터 스트림
    """
    client = TardisClient(TARDIS_API_KEY)
    
    # Deribit BTC期权 만기일 목록 조회
    exchange = client.exchange("deribit")
    
    # 2024년 6월 BTC PUT 옵션 스트림
    replay = client.replay(
        exchange="deribit",
        filters=[
            {"type": "book", "symbols": ["BTC-28JUN24-65000-P"]},
            {"type": "trade", "symbols": ["BTC-28JUN24-65000-P"]}
        ],
        from_timestamp=datetime(2024, 6, 1).timestamp() * 1000,
        to_timestamp=datetime(2024, 6, 28).timestamp() * 1000
    )
    
    trade_data = []
    book_data = []
    
    async for local_timestamp, data in replay:
        if data["type"] == "trade":
            trade_data.append({
                "timestamp": local_timestamp,
                "price": data["data"]["price"],
                "amount": data["data"]["amount"],
                "side": data["data"]["side"]
            })
        elif data["type"] == "book":
            book_data.append({
                "timestamp": local_timestamp,
                "best_bid": data["data"]["bids"][0][0] if data["data"]["bids"] else None,
                "best_ask": data["data"]["asks"][0][0] if data["data"]["asks"] else None,
                "bid_size": data["data"]["bids"][0][1] if data["data"]["bids"] else 0,
                "ask_size": data["data"]["asks"][0][1] if data["data"]["asks"] else 0
            })
    
    # DataFrame 변환
    df_trades = pd.DataFrame(trade_data)
    df_books = pd.DataFrame(book_data)
    
    print(f"📊 체결 데이터: {len(df_trades)}건")
    print(f"📊 오더북 데이터: {len(df_books)}건")
    
    return df_trades, df_books


실행

df_trades, df_books = asyncio.run(stream_deribit_options())

波动率计算 및 백테스트

이제 다운로드한 데이터를 활용하여 실제 历史波动率(HV)과 암묵적波动率(IV)을 계산하고, 간단한 트레이딩 전략을 백테스트해보겠습니다.

import pandas as pd
import numpy as np
from scipy.stats import norm
from datetime import datetime


======== Deribit期权数据事前処理 ========

def preprocess_options_data(df_candles, df_trades):
    """
    원시 데이터를 옵션 분석에 적합한 형태로 가공
    """
    # 가격 데이터 정제
    df = df_candles.copy()
    df['timestamp'] = pd.to_datetime(df['timestamp'])
    df.set_index('timestamp', inplace=True)
    
    # 일별 수익률 계산
    df['returns'] = df['close'].pct_change()
    
    # 거래량 가중 평균 가격 (VWAP)
    df['vwap'] = (df['close'] * df['volume']).cumsum() / df['volume'].cumsum()
    
    # 체결 데이터 병합
    if df_trades is not None and len(df_trades) > 0:
        df_trades['timestamp'] = pd.to_datetime(df_trades['timestamp'])
        df['trade_count'] = df_trades.groupby(df_trades['timestamp'].dt.floor('1min')).size()
    
    return df


======== 历史波动率(HV) 计算 ========

def calculate_historical_volatility(df, window=20):
    """
    과거 수익률 기반 역사적 변동성 계산
    
    HV = √(252) × σ(log returns)
    
    Parameters:
        df: 가격 데이터 DataFrame
        window: 계산 기간 (일)
    
    Returns:
        float: 연간화된 변동성 (%)
    """
    log_returns = np.log(df['close'] / df['close'].shift(1))
    daily_vol = log_returns.rolling(window=window).std()
    annualized_vol = daily_vol * np.sqrt(252) * 100  # %로 변환
    
    return annualized_vol


======== 隐含波动率(IV) 计算 (Black-Scholes逆算) ========

def calculate_implied_volatility(
    market_price, 
    S,      # 현물 가격
    K,      # 행사가
    T,      # 만기까지 시간 (년)
    r,      # 무위험 금리
    option_type="put"
):
    """
    시장 가격으로부터 암묵적 변동성 역산
    
    Newton-Raphson 방법 사용
    """
    from scipy.optimize import brentq
    
    def black_scholes_price(S, K, T, r, sigma, option_type):
        d1 = (np.log(S/K) + (r + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
        d2 = d1 - sigma*np.sqrt(T)
        
        if option_type == "call":
            price = S*norm.cdf(d1) - K*np.exp(-r*T)*norm.cdf(d2)
        else:  # put
            price = K*np.exp(-r*T)*norm.cdf(-d2) - S*norm.cdf(-d1)
        return price
    
    def objective(sigma):
        return black_scholes_price(S, K, T, r, sigma, option_type) - market_price
    
    try:
        # IV 범위 제한 (1%~500%)
        iv = brentq(objective, 0.01, 5.0)
        return iv * 100  # %로 변환
    except:
        return None


======== 백테스트: HV-IV 스프레드 전략 ========

def backtest_hv_iv_strategy(df, hv_window=20, iv_threshold=5):
    """
    역사적 변동성과 암묵적 변동성의 차이를 활용한 전략 백테스트
    
    신호:
    - HV > IV + 임계값 → 변동성 과대평가 → PUT 매도
    - HV < IV - 임계값 → 변동성 과소평가 → PUT 매수
    """
    results = []
    
    df['hv'] = calculate_historical_volatility(df, window=hv_window)
    
    # 스트라이크 및 만기 정보 파싱
    instrument = "BTC-28JUN24-65000-P"
    strike = 65000
    expiry = datetime(2024, 6, 28)
    
    for idx, row in df.iterrows():
        if pd.isna(row['hv']):
            continue
        
        # 일별 만기 시간 계산
        T = (expiry - idx).days / 365
        
        if T <= 0 or row['close'] <= 0:
            continue
        
        # IV 역산
        iv = calculate_implied_volatility(
            market_price=row['close'],
            S=row['close'] * 1.05,  # 현물 근사치 (실제로는 BTC 가격 사용)
            K=strike,
            T=T,
            r=0.05  # 무위험 금리 5%
        )
        
        if iv is None:
            continue
        
        df.loc[idx, 'iv'] = iv
        df.loc[idx, 'hv_iv_spread'] = row['hv'] - iv
        
        # 거래 신호
        spread = df.loc[idx, 'hv_iv_spread']
        
        if spread > iv_threshold:
            signal = "SELL_VOL"  # 변동성 매도
        elif spread < -iv_threshold:
            signal = "BUY_VOL"   # 변동성 매수
        else:
            signal = "HOLD"
        
        df.loc[idx, 'signal'] = signal
    
    return df


======== 메인 실행 ========


데이터预处理

df_processed = preprocess_options_data(df_ohlcv, df_trades)


백테스트 실행

df_backtest = backtest_hv_iv_strategy(df_processed)

print("=" * 60)
print("백테스트 결과 요약")
print("=" * 60)
print(f"전체 데이터 포인트: {len(df_backtest)}")
print(f"평균 HV: {df_backtest['hv'].mean():.2f}%")
print(f"평균 IV: {df_backtest['iv'].mean():.2f}%")
print(f"HV-IV 스프레드 평균: {df_backtest['hv_iv_spread'].mean():.2f}%")
print(f"\n신호 분포:")
print(df_backtest['signal'].value_counts())

HolySheep AI로 분석 결과 자동 요약

이제 백테스트 결과를 HolySheep AI API를 사용하여 자연어로 요약해보겠습니다. HolySheep AI는 다양한 모델을 단일 API 키로 통합하여 제공합니다.

import requests
import json
import os


======== HolySheep AI API 설정 ========

HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"


======== 백테스트 결과를 기반으로 요약 프롬프트 생성 ========

def generate_summary_prompt(df_backtest):
    """
    백테스트 결과를 HolySheep AI가 분석할 수 있는 프롬프트로 변환
    """
    summary_stats = {
        "total_data_points": len(df_backtest),
        "avg_historical_volatility": round(df_backtest['hv'].mean(), 2),
        "avg_implied_volatility": round(df_backtest['iv'].mean(), 2),
        "hv_iv_spread_avg": round(df_backtest['hv_iv_spread'].mean(), 2),
        "hv_iv_spread_max": round(df_backtest['hv_iv_spread'].max(), 2),
        "hv_iv_spread_min": round(df_backtest['hv_iv_spread'].min(), 2),
        "signal_distribution": df_backtest['signal'].value_counts().to_dict(),
        "price_range": {
            "min": round(df_backtest['low'].min(), 2),
            "max": round(df_backtest['high'].max(), 2),
            "final": round(df_backtest['close'].iloc[-1], 2)
        }
    }
    
    prompt = f"""
당신은 암호화폐 옵션 트레이딩 전문가입니다. 
아래 Deribit BTC PUT 옵션(행사가: $65,000, 만기: 2024-06-28)의 
백테스트 결과를 분석하고 한국어로 요약해주세요.

【백테스트 결과】
{json.dumps(summary_stats, ensure_ascii=False, indent=2)}

【분석 요청】
1. HV-IV 스프레드의 의미를 설명해주세요.
2. 현재 시장 변동성 과대평가/과소평가 여부를 판단해주세요.
3. 트레이딩 신호 빈도를 바탕으로 시장 심리을 분석해주세요.
4. 투자자 시점에서의 주의사항을 제시해주세요.

한국어로 명확하고 전문적인 분석을 제공해주세요.
"""
    
    return prompt


======== HolySheep AI API 호출 ========

def call_holysheep_ai(prompt, model="gpt-4.1"):
    """
    HolySheep AI를 통해 백테스트 결과 요약 생성
    
    HolySheep AI 가격 (2025년 5월 기준):
    - GPT-4.1: $8.00/1M 토큰
    - Claude Sonnet 4.5: $15.00/1M 토큰
    - Gemini 2.5 Flash: $2.50/1M 토큰 (가장 경제적)
    - DeepSeek V3.2: $0.42/1M 토큰 (최저가)
    """
    
    url = f"{HOLYSHEEP_BASE_URL}/chat/completions"
    
    headers = {
        "Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": model,
        "messages": [
            {"role": "system", "content": "당신은 전문적인 암호화폐 금융 분석가입니다."},
            {"role": "user", "content": prompt}
        ],
        "temperature": 0.7,
        "max_tokens": 2000
    }
    
    print(f"🔄 HolySheep AI ({model}) 분석 중...")
    
    response = requests.post(url, headers=headers, json=payload, timeout=60)
    
    if response.status_code == 200:
        result = response.json()
        content = result['choices'][0]['message']['content']
        usage = result.get('usage', {})
        
        print(f"✅ 분석 완료!")
        print(f"   사용 토큰: {usage.get('total_tokens', 'N/A')}")
        print(f"   비용(약): ${usage.get('total_tokens', 0) / 1_000_000 * 8:.4f} (GPT-4.1 기준)")
        
        return content
    else:
        print(f"❌ API 오류: {response.status_code}")
        print(f"   {response.text}")
        return None


======== 메인 실행 ========

prompt = generate_summary_prompt(df_backtest)
analysis_result = call_holysheep_ai(prompt, model="gpt-4.1")

if analysis_result:
    print("\n" + "=" * 70)
    print("📊 HolySheep AI 분석 결과")
    print("=" * 70)
    print(analysis_result)

비용 최적화: HolySheep AI 모델 비교

Deribit 데이터 분석처럼 대량의 백테스트 결과를 반복적으로 요약해야 하는 경우, HolySheep AI의 모델별 가격 차이를 활용하면 비용을 크게 절감할 수 있습니다.

모델 입력 비용 출력 비용 호환성 권장 용도 1M 토큰당 비용
DeepSeek V3.2 $0.42/MTok $0.42/MTok OpenAI 호환 대량 요약, 반복 분석 최저가 ★
Gemini 2.5 Flash $2.50/MTok $10.00/MTok OpenAI 호환 빠른 분석, 실시간 처리 저렴
GPT-4.1 $8.00/MTok $8.00/MTok OpenAI 네이티브 정밀한 금융 분석 중간
Claude Sonnet 4.5 $15.00/MTok $15.00/MTok OpenAI 호환 긴 컨텍스트 분석 고가

비용 절감 실전 예시

저는 실제로 월 100회 백테스트를 실행하고 각 결과를 HolySheep AI로 요약하는 파이프라인을 운영합니다. 월간 토큰 사용량은 약 5M입니다.

완전한 워크플로우 예제

# ======== 통합 워크플로우: 데이터 다운로드 → 백테스트 → AI 요약 ========

import requests
import pandas as pd
import numpy as np
from datetime import datetime

class DeribitOptionsAnalyzer:
    """
    Deribit期权数据收集、波动率分析、HolySheep AI 요약 통합 클래스
    """
    
    def __init__(self, tardis_key, holysheep_key):
        self.tardis_key = tardis_key
        self.holysheep_key = holysheep_key
        self.holysheep_url = "https://api.holysheep.ai/v1/chat/completions"
        self.tardis_url = "https://api.tardis.dev/v1"
    
    def download_options_data(self, instrument, start_date, end_date):
        """Tardis에서期权数据下载"""
        # ... (이전 코드参照)
        pass
    
    def calculate_volatility(self, df, window=20):
        """변동성 계산"""
        log_returns = np.log(df['close'] / df['close'].shift(1))
        hv = log_returns.rolling(window).std() * np.sqrt(252) * 100
        return hv
    
    def generate_analysis_with_ai(self, df_analysis, model="deepseek-chat"):
        """HolySheep AI로 분석 결과 요약"""
        
        # 분석 결과 텍스트화
        analysis_text = f"""
        【Deribit BTC PUT 옵션 백테스트 결과】
        - 분석 기간: {df_analysis.index.min()} ~ {df_analysis.index.max()}
        - 평균 역사적 변동성: {df_analysis['hv'].mean():.2f}%
        - 평균 암묵적 변동성: {df_analysis['iv'].mean():.2f}%
        - HV-IV 스프레드: {df_analysis['hv_iv_spread'].mean():.2f}%
        - 매도 신호: {(df_analysis['signal'] == 'SELL_VOL').sum()}회
        - 매수 신호: {(df_analysis['signal'] == 'BUY_VOL').sum()}회
        """
        
        headers = {
            "Authorization": f"Bearer {self.holysheep_key}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "model": model,
            "messages": [
                {"role": "system", "content": "당신은 전문 트레이딩 분석가입니다."},
                {"role": "user", "content": f"아래 백테스트 결과를 한국어로 요약해주세요:\n{analysis_text}"}
            ],
            "temperature": 0.5,
            "max_tokens": 1500
        }
        
        response = requests.post(
            self.holysheep_url, 
            headers=headers, 
            json=payload,
            timeout=60
        )
        
        if response.status_code == 200:
            return response.json()['choices'][0]['message']['content']
        else:
            raise Exception(f"API 오류: {response.status_code}")


======== 사용 예시 ========

analyzer = DeribitOptionsAnalyzer(
    tardis_key="YOUR_TARDIS_KEY",
    holysheep_key="YOUR_HOLYSHEEP_API_KEY"
)


데이터 다운로드 및 분석

df = analyzer.download_options_data(
    instrument="BTC-28JUN24-65000-P",
    start_date="2024-06-01",
    end_date="2024-06-28"
)


HolySheep AI로 요약 (DeepSeek 사용 시 95% 비용 절감)

result = analyzer.generate_analysis_with_ai(df, model="deepseek-chat")
print(result)

이런 팀에 적합 / 비적합

✅ 이런 팀에 적합

❌ 이런 팀에는 비적용

가격과 ROI

서비스 플랜 월간 비용 주요 기능 ROI 관점
Tardis Machine Free $0 30일 히스토리, 1분봉 학습·테스트용
Tardis Machine Starter $29 1년 히스토리, 모든 intervals 소규모 분석
Tardis Machine Pro $99 5년 히스토리, WebSocket 무제한 전문 트레이딩
HolySheep AI 무료 크레딧 $0 500K 토큰 무료 초기 테스트
HolySheep AI 유료 사용량 기반 DeepSeek $0.42/MTok 대량 분석 시 최고 가성비

저의 실제 비용 분석

저는 개인 퀀트 프로젝트로 HolySheep AI를 사용합니다:

왜 HolySheep AI를 선택해야 하나

1. 로컬 결제 지원

해외 신용카드 없이도 PayPal, 국내 은행转账, Cryptocurrency로 결제 가능합니다. 저는 처음에 해외 서비스 결제를 걱정했는데, HolySheep AI는 한국 개발자에게 매우 친숙한 결제 옵션을 제공합니다.

2. 단일 API 키로 모든 주요 모델 통합

# 하나의 API 키로 여러 모델 사용 가능
import openai

client = openai.OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1"
)


GPT-4.1로 분석

response_gpt = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": "분석해줘"}]
)


DeepSeek로 요약 (90% 저렴)

response_deepseek = client.chat.completions.create(
    model="deepseek-chat",
    messages=[{"role": "user", "content": "요약해줘"}]
)


Claude도 가능

response_claude = client.chat.completions.create(
    model="claude-sonnet-4-20250514",
    messages=[{"role": "user", "content": "비교해줘"}]
)

3. 업계 최저가 보장

공식 OpenAI HolySheep AI 절감
GPT-4.1: $8.00/MTok DeepSeek V3.2: $0.42/MTok 95% 절감
Claude Sonnet: $15.00/MTok Gemini 2.5 Flash: $2.50/MTok 83% 절감

자주 발생하는 오류와 해결책

오류 1: Tardis API 401 Unauthorized

# ❌ 오류 메시지

{"error": "Invalid API key"}



✅ 해결 방법


1. API 키가 정확한지 확인

TARDIS_API_KEY = "ts_xxxxxxxxxxxxxxxxxxxxxxxx"  # ts_ 접두사 필수


2. 키가 활성화되어 있는지 확인


https://app.tardis.dev/settings/api-keys 에서 상태 확인



3. 사용량 한도 확인 (무료 플랜: 월 30일 히스토리)


해결: 유료 플랜 업그레이드 또는 데이터 범위 축소

오류 2: HolySheep AI Rate LimitExceeded

# ❌ 오류 메시지

{"error": {"message": "Rate limit exceeded", "type": "requests"}}



✅ 해결 방법


1. 재시도 로직 추가 (지수 백오프)

import time
import requests

def call_with_retry(url, headers, payload, max_retries=3):
    for attempt in range(max_retries):
        response = requests.post(url, headers=headers, json=payload)
        if response.status_code != 429:
            return response
        
        wait_time = 2 ** attempt  # 1초, 2초, 4초 대기
        print(f"⏳ Rate limit 대기 중... {wait_time}초")
        time.sleep(wait_time)
    
    raise Exception("최대 재시도 횟수 초과")


2. 배치 처리로 호출 수 감소


기존: 100회 개별 호출 → 개선: 100회 → 1회 배치 호출

오류 3: Deribit 옵션 심볼 형식 오류

# ❌ 오류 메시지

{"error": "Symbol not found"}



✅ Deribit 옵션 심볼 형식 이해


형식: {underlying}-{expiry}{day}{mon}{year}-{strike}-{type}



예시들:


BTC-28JUN24-65000-P  → BTC, 2024년 6월 28일, 행사가 $65,000, PUT


BTC-29DEC23-50000-C  → BTC, 2023년 12월


관련 리소스
관련 문서