핵심 결론: 왜 이 튜토리얼이 중요한가

암호화폐 USDT永续계약(Perpetual Futures)은 레버리지 거래의 핵심 도구입니다. 2024년 기준 Binance, Bybit, OKX 등 주요 거래소에서 일평균 500억 달러 이상의 거래량이 발생하며, 개인 트레이더부터 헤지펀드까지 모두가 정확한 백테스팅 도구를 필요로 합니다.

이 튜토리얼의 핵심 가치:

결론부터 말씀드리면: 단기·고빈도 전략은 VectorBT, 장기·복잡한 전략은 Backtrader가 적합합니다. HolySheep AI를 사용하면 월 50달러 수준의 비용으로 전문적인 백테스팅 인프라를 구축할 수 있습니다.

HolySheep AI vs 공식 API vs 경쟁 서비스 비교

비교 항목 HolySheep AI OpenAI 공식 Anthropic 공식 Google AI
GPT-4.1 가격 $8.00/MTok $8.00/MTok - -
Claude Sonnet 4 $15.00/MTok - $15.00/MTok -
Gemini 2.5 Flash $2.50/MTok - - $1.25/MTok
DeepSeek V3.2 $0.42/MTok - - -
평균 지연 시간 180ms 350ms 400ms 280ms
해외 신용카드 필요 ❌ 불필요 ✅ 필요 ✅ 필요 ✅ 필요
한국 원화 결제 ✅ 지원 ❌ 미지원 ❌ 미지원 ❌ 미지원
단일 API 키 ✅ 10+ 모델 ❌ 단일 ❌ 단일 ❌ 단일
무료 크레딧 ✅ 제공 $5 크레딧 $5 크레딧 $300 크레딧

Backtrader vs VectorBT 아키텍처 비교

Backtrader 특징

Backtrader는 Python 기반의 클래식한 이벤트 드리븐 백테스팅 프레임워크입니다. 2015년부터 유지 관리되고 있으며, 금융 전문가들에게 널리 사용됩니다.

장점:

단점:

VectorBT 특징

VectorBT는 NumPy와 Numba JIT 컴파일을 활용한 벡터화 백테스팅 프레임워크입니다. Pandas مقابل 100배 빠른 속도를 자랑합니다.

장점:

단점:

실전 백테스트 구현

1. 환경 설정과 필수 라이브러리

# requirements.txt

backtest-env.yml


name: crypto-backtest
channels:
  - conda-forge
  - defaults
dependencies:
  - python=3.11
  - pandas>=2.0.0
  - numpy>=1.24.0
  - matplotlib>=3.7.0
  - jupyterlab>=4.0.0
  - pip
  - pip:
    - backtrader>=1.9.78
    - vectorbt>=0.25.0
    - ccxt>=4.0.0
    - ta-lib>=0.4.28
    - plotly>=5.15.0
    - holytools @ https://github.com/holysheepai/holytools/releases/download/v1.2.0/holytools-1.2.0-py3-none-any.whl


설치 명령어


conda env create -f backtest-env.yml


conda activate crypto-backtest

2. HolySheep AI API 기반 전략 분석기

"""
BTC-USDT永续契約 AI 分析器
HolySheep AI API를 활용한 자동화된 전략 분석
"""

import os
import json
import requests
from typing import Dict, List, Optional
from dataclasses import dataclass
from datetime import datetime

@dataclass
class StrategyAnalysis:
    strategy_name: str
    sharpe_ratio: float
    max_drawdown: float
    total_return: float
    win_rate: float
    ai_insights: str

class HolySheepAIClient:
    """HolySheep AI API 클라이언트 - 백테스트 분석용"""
    
    BASE_URL = "https://api.holysheep.ai/v1"
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
    
    def analyze_backtest_results(
        self, 
        strategy_name: str,
        backtest_data: Dict,
        model: str = "gpt-4.1"
    ) -> StrategyAnalysis:
        """
        백테스트 결과를 AI가 분석하여 개선점을 제안
        
        Args:
            strategy_name: 전략 이름
            backtest_data: 백테스트 결과 딕셔너리
            model: 사용할 AI 모델 (기본값: gpt-4.1)
        
        Returns:
            StrategyAnalysis: AI 분석 결과
        """
        
        prompt = f"""당신은 암호화폐量化투자 전문가입니다. 
다음 BTC-USDT永续契約 백테스트 결과를 분석하고 개선점을 제안해주세요.

【백테스트 결과】
- 전략명: {strategy_name}
- 총 수익률: {backtest_data.get('total_return', 0):.2f}%
- 샤프 비율: {backtest_data.get('sharpe_ratio', 0):.2f}
- 최대 드로우다운: {backtest_data.get('max_drawdown', 0):.2f}%
- 승률: {backtest_data.get('win_rate', 0):.2f}%
- 총 거래 횟수: {backtest_data.get('total_trades', 0)}
- 평균 거래 시간: {backtest_data.get('avg_holding_period', 0):.2f}시간

【분석 요청】
1. 이 전략의 주요 장점 3가지
2. 개선이 필요한 부분 3가지
3. 구체적인 파라미터 조정 제안
4. 리스크 관리 개선점

한국어로 상세하게 답변해주세요."""
        
        payload = {
            "model": model,
            "messages": [
                {"role": "system", "content": "당신은 전문적인 암호화폐量化투자 컨설턴트입니다."},
                {"role": "user", "content": prompt}
            ],
            "temperature": 0.7,
            "max_tokens": 2000
        }
        
        response = requests.post(
            f"{self.BASE_URL}/chat/completions",
            headers=self.headers,
            json=payload,
            timeout=30
        )
        
        if response.status_code != 200:
            raise Exception(f"API 호출 실패: {response.status_code} - {response.text}")
        
        result = response.json()
        ai_insights = result["choices"][0]["message"]["content"]
        
        return StrategyAnalysis(
            strategy_name=strategy_name,
            sharpe_ratio=backtest_data.get('sharpe_ratio', 0),
            max_drawdown=backtest_data.get('max_drawdown', 0),
            total_return=backtest_data.get('total_return', 0),
            win_rate=backtest_data.get('win_rate', 0),
            ai_insights=ai_insights
        )
    
    def optimize_parameters(
        self,
        base_strategy: str,
        historical_data: List[Dict],
        budget_tokens: int = 50000
    ) -> List[Dict]:
        """
        HolySheep AI를 활용하여 최적의 전략 파라미터를 탐색
        
        Args:
            base_strategy: 기본 전략 설명
            historical_data:.historical_price_data
            budget_tokens: 예상 사용 토큰 (비용 최적화용)
        
        Returns:
            최적화된 파라미터 목록
        """
        
        #DeepSeek V3.2 사용 (가장 저렴한 모델)
        prompt = f"""다음 BTC-USDT永续契約 기반 전략의 최적 파라미터를 제안해주세요.

【기본 전략】
{base_strategy}

【최근 데이터 샘플】
{json.dumps(historical_data[:10], indent=2)}

【조건】
- 레버리지: 1x~10x
- 슬리피지: 0.05% 이내
- 최소 거래 금액: $100
- 최대 하루 거래 횟수: 10회

【출력 형식】
{{
  "optimal_params": {{
    "rsi_period": 14,
    "ma_short": 20,
    "ma_long": 50,
    "volume_threshold": 1.5,
    "stop_loss_pct": 2.0,
    "take_profit_pct": 5.0
  }},
  "expected_metrics": {{
    "sharpe_ratio": 1.8,
    "max_drawdown": 15.0,
    "win_rate": 0.65
  }}
}}"""
        
        payload = {
            "model": "deepseek-chat",
            "messages": [{"role": "user", "content": prompt}],
            "temperature": 0.3,
            "max_tokens": 1500
        }
        
        response = requests.post(
            f"{self.BASE_URL}/chat/completions",
            headers=self.headers,
            json=payload
        )
        
        result = response.json()
        return json.loads(result["choices"][0]["message"]["content"])


===== 실제 사용 예시 =====

if __name__ == "__main__":
    # HolySheep AI API 초기화
    client = HolySheepAIClient(api_key="YOUR_HOLYSHEEP_API_KEY")
    
    # 샘플 백테스트 결과
    sample_backtest = {
        'total_return': 45.8,
        'sharpe_ratio': 1.95,
        'max_drawdown': -12.3,
        'win_rate': 0.62,
        'total_trades': 156,
        'avg_holding_period': 8.5
    }
    
    # AI 분석 요청
    analysis = client.analyze_backtest_results(
        strategy_name="RSI + MACD Divergence",
        backtest_data=sample_backtest,
        model="gpt-4.1"  # $8/MTok - 고품질 분석
    )
    
    print(f"📊 전략: {analysis.strategy_name}")
    print(f"💰 총 수익률: {analysis.total_return}%")
    print(f"📈 샤프 비율: {analysis.sharpe_ratio}")
    print(f"⚠️ 최대 드로우다운: {analysis.max_drawdown}%")
    print(f"\n🤖 AI 분석:\n{analysis.ai_insights}")
    
    # 비용 확인
    # gpt-4.1: $8/MTok × 약 0.5K tokens = $0.004 (약 5원)

3. Backtrader를使ったBTC永续契約バックテスト

"""
Backtrader 기반 BTC-USDT永续契約 バックテスト
- 이동평균 교차 전략
- RSI 필터 적용
- HolySheep AI로パラメータ最適化
"""

import backtrader as bt
import ccxt
import pandas as pd
from datetime import datetime, timedelta
from holytools import HolySheepAIClient

class RSIMACrossStrategy(bt.Strategy):
    """
    RSI 필터가 적용된 이동평균 교차 전략
    - 골든크로스: MA_short > MA_long + RSI 조건 충족 → 매수
    - 데드크로스: MA_short < MA_long → 매도
    """
    
    params = (
        ('ma_short', 20),
        ('ma_long', 50),
        ('rsi_period', 14),
        ('rsi_lower', 35),
        ('rsi_upper', 65),
        ('stop_loss', 0.02),  # 2% 스탑로스
        ('take_profit', 0.05),  # 5% 테이크프로핏
        ('printlog', False),
    )
    
    def __init__(self):
        # 이동평균선
        self.ma_short = bt.indicators.SMA(
            self.data.close, 
            period=self.params.ma_short
        )
        self.ma_long = bt.indicators.SMA(
            self.data.close, 
            period=self.params.ma_long
        )
        
        # RSI
        self.rsi = bt.indicators.RSI(
            self.data.close, 
            period=self.params.rsi_period
        )
        
        # 매수/매도 시그널
        self.crossover = bt.indicators.CrossOver(
            self.ma_short, 
            self.ma_long
        )
        
        # 주문 관리
        self.order = None
        self.buy_price = None
        self.buy_comm = None
        
    def log(self, txt, dt=None):
        if self.params.printlog:
            dt = dt or self.datas[0].datetime.date(0)
            print(f'{dt.isoformat()} {txt}')
    
    def notify_order(self, order):
        if order.status in [order.Submitted, order.Accepted]:
            return
        
        if order.status in [order.Completed]:
            if order.isbuy():
                self.log(f'BUY EXECUTED, Price: {order.executed.price:.2f}')
                self.buy_price = order.executed.price
                self.buy_comm = order.executed.comm
            else:
                self.log(f'SELL EXECUTED, Price: {order.executed.price:.2f}')
            
        elif order.status in [order.Canceled, order.Margin, order.Rejected]:
            self.log('Order Canceled/Margin/Rejected')
        
        self.order = None
    
    def notify_trade(self, trade):
        if not trade.isclosed:
            return
        self.log(f'OPERATION PROFIT, GROSS {trade.pnl:.2f}, NET {trade.pnlcomm:.2f}')
    
    def next(self):
        if self.order:
            return
        
        # 매수 조건: 골든크로스 + RSI 과매도 구간 이탈
        if not self.position:
            if self.crossover > 0 and self.rsi > self.params.rsi_lower:
                self.log(f'BUY CREATE, {self.data.close[0]:.2f}')
                self.order = self.buy()
        
        # 매도 조건: 데드크로스
        else:
            if self.crossover < 0:
                self.log(f'SELL CREATE, {self.data.close[0]:.2f}')
                self.order = self.sell()
            
            # 스탑로스/테이크프로핏 체크
            else:
                pnl_pct = (self.data.close[0] - self.buy_price) / self.buy_price
                
                if pnl_pct <= -self.params.stop_loss:
                    self.log(f'STOP LOSS, PnL: {pnl_pct*100:.2f}%')
                    self.order = self.sell()
                
                elif pnl_pct >= self.params.take_profit:
                    self.log(f'TAKE PROFIT, PnL: {pnl_pct*100:.2f}%')
                    self.order = self.sell()
    
    def stop(self):
        self.log(f'(MA Short={self.params.ma_short}, Long={self.params.ma_long}) '
                 f'Ending Value {self.broker.getvalue():.2f}', dt=self.datas[0].datetime.date(0))


def fetch_binance_perpetual_data(symbol: str = "BTC/USDT:USDT", 
                                  timeframe: str = "1h",
                                  days: int = 365) -> pd.DataFrame:
    """
    Binance에서 BTC-USDT永续契約 데이터 가져오기
    ccxt 라이브러리 사용
    """
    exchange = ccxt.binance({
        'options': {'defaultType': 'future'}
    })
    
    end_date = datetime.now()
    start_date = end_date - timedelta(days=days)
    
    ohlcv = exchange.fetch_ohlcv(
        symbol,
        timeframe=timeframe,
        since=int(start_date.timestamp() * 1000),
        limit=2000
    )
    
    df = pd.DataFrame(
        ohlcv, 
        columns=['datetime', 'open', 'high', 'low', 'close', 'volume']
    )
    df['datetime'] = pd.to_datetime(df['datetime'], unit='ms')
    df.set_index('datetime', inplace=True)
    
    return df


def run_backtest():
    """메인 백테스트 실행"""
    
    # HolySheep AI 클라이언트 초기화
    ai_client = HolySheepAIClient(api_key="YOUR_HOLYSHEEP_API_KEY")
    
    print("=" * 60)
    print("BTC-USDT永续契約 バックテスト")
    print("戦略: RSI + 移動平均交差")
    print("=" * 60)
    
    # 데이터 가져오기
    print("\n[1/4] Binance에서 데이터 가져오는 중...")
    data = fetch_binance_perpetual_data(days=180)  # 6개월 데이터
    
    # Backtrader 데이터 피드 생성
    data_feed = bt.feeds.PandasData(
        dataname=data,
        datetime=None,
        open='open',
        high='high',
        low='low',
        close='close',
        volume='volume',
        openinterest=-1
    )
    
    # Cerebro 엔진 생성
    cerebro = bt.Cerebro(
        cheat_on_open=True,
        broker_cookieval=True
    )
    
    cerebro.adddata(data_feed)
    cerebro.broker.setcash(10000.0)  # 초기 자본 $10,000
    cerebro.broker.setcommission(commission=0.0004)  # 마크업 포함 0.04%
    cerebro.addsizer(bt.sizers.PercentSizer, percents=20)  # 1회 최대 20% 투자
    
    # 전략 파라미터 최적화
    print("[2/4] 파라미터 최적화 중...")
    
    # HolySheep AI를 통한 최적 파라미터 탐색
    historical = data.tail(10).to_dict('records')
    optimized = ai_client.optimize_parameters(
        base_strategy="RSI 필터가 적용된 이동평균 교차 전략",
        historical_data=historical,
        budget_tokens=30000  # $0.42/MTok × 30K = $12.6
    )
    
    print(f"AI 추천 파라미터: {optimized.get('optimal_params', {})}")
    
    # 최적화된 파라미터로 전략 추가
    cerebro.addstrategy(
        RSIMACrossStrategy,
        ma_short=optimized.get('optimal_params', {}).get('ma_short', 20),
        ma_long=optimized.get('optimal_params', {}).get('ma_long', 50),
        rsi_period=14,
        stop_loss=optimized.get('optimal_params', {}).get('stop_loss_pct', 0.02),
        take_profit=optimized.get('optimal_params', {}).get('take_profit_pct', 0.05)
    )
    
    # 분석기 추가
    cerebro.addanalyzer(bt.analyzers.SharpeRatio, _name='sharpe')
    cerebro.addanalyzer(bt.analyzers.DrawDown, _name='drawdown')
    cerebro.addanalyzer(bt.analyzers.Returns, _name='returns')
    cerebro.addanalyzer(bt.analyzers.TradeAnalyzer, _name='trades')
    
    print(f"[3/4] 초기 자본: ${cerebro.broker.getvalue():,.2f}")
    
    # 백테스트 실행
    results = cerebro.run()
    strat = results[0]
    
    final_value = cerebro.broker.getvalue()
    print(f"[4/4] 최종 자본: ${final_value:,.2f}")
    print(f"수익률: {(final_value/10000-1)*100:.2f}%")
    
    # 분석 결과
    print("\n" + "=" * 60)
    print("【백테스트 결과】")
    print("=" * 60)
    
    sharpe = strat.analyzers.sharpe.get_analysis()
    drawdown = strat.analyzers.drawdown.get_analysis()
    returns = strat.analyzers.returns.get_analysis()
    trades = strat.analyzers.trades.get_analysis()
    
    print(f"샤프 비율: {sharpe.get('sharperatio', 'N/A')}")
    print(f"최대 드로우다운: {drawdown.get('max', {}).get('drawdown', 0):.2f}%")
    print(f"총 수익률: {returns.get('rtot', 0)*100:.2f}%")
    
    # HolySheep AI로 상세 분석
    backtest_summary = {
        'total_return': (final_value/10000-1)*100,
        'sharpe_ratio': sharpe.get('sharperatio', 0) or 0,
        'max_drawdown': drawdown.get('max', {}).get('drawdown', 0),
        'win_rate': trades.get('won', {}).get('total', 0) / max(trades.get('total', {}).get('total', 1), 1),
        'total_trades': trades.get('total', {}).get('total', 0),
        'avg_holding_period': 8.5
    }
    
    print("\n[AI 분석 요청 중...HolySheep AI]")
    analysis = ai_client.analyze_backtest_results(
        strategy_name="RSI + MA Cross with AI Optimization",
        backtest_data=backtest_summary
    )
    
    print(f"\n{'='*60}")
    print("【HolySheep AI 분석 결과】")
    print(f"{'='*60}")
    print(analysis.ai_insights)
    
    return backtest_summary


if __name__ == '__main__':
    result = run_backtest()

4. VectorBT를 활용한高速백테스트

"""
VectorBT 기반 BTC-USDT永续契約 高速 백테스트
- 풀 벡터화 연산으로 초고속 시뮬레이션
- 파라미터 그리드 서치
- HolySheep AI로 전략 자동 생성
"""

import vectorbt as vbt
import ccxt
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
import requests
from typing import Dict, List


HolySheep AI 클라이언트 (간단 버전)

class HolySheepAIClient:
    BASE_URL = "https://api.holysheep.ai/v1"
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
    
    def generate_strategy_code(self, description: str, model: str = "deepseek-chat") -> str:
        """
        HolySheep DeepSeek V3.2를 활용하여 VectorBT 전략 코드 생성
        비용: $0.42/MTok (가장 저렴)
        """
        
        prompt = f"""다음 전략 설명을 VectorBT Python 코드로 변환해주세요.

【전략 설명】
{description}

【조건】
- Python 3.11 호환
- vectorbt v0.25 이상
- portfolio factory: 'pf' 사용
- entries/exits: Boolean Series 반환
- 반드시 실행 가능한 완전한 코드

【코드 템플릿】

import vectorbt as vbt
import pandas as pd
import numpy as np

def your_strategy(close, high, low, volume, **params):
    # 전략 로직 구현
    entries = ...  # 매수 시그널
    exits = ...    # 매도 시그널
    
    pf = vbt.Portfolio.from_signals(
        close,
        entries=entries,
        exits=exits,
        **params
    )
    return pf

"""
        
        payload = {
            "model": model,
            "messages": [{"role": "user", "content": prompt}],
            "temperature": 0.2,
            "max_tokens": 2500
        }
        
        response = requests.post(
            f"{self.BASE_URL}/chat/completions",
            headers=self.headers,
            json=payload,
            timeout=45
        )
        
        result = response.json()
        return result["choices"][0]["message"]["content"]


def fetch_crypto_data(symbol: str = "BTC/USDT:USDT",
                      timeframe: str = "1h",
                      days: int = 365) -> pd.DataFrame:
    """Binance永续契約 데이터 가져오기"""
    
    exchange = ccxt.binance({
        'options': {'defaultType': 'future'},
        'enableRateLimit': True
    })
    
    end_date = datetime.now()
    start_date = end_date - timedelta(days=days)
    
    ohlcv = exchange.fetch_ohlcv(
        symbol,
        timeframe=timeframe,
        since=int(start_date.timestamp() * 1000),
        limit=2000
    )
    
    df = pd.DataFrame(
        ohlcv,
        columns=['timestamp', 'open', 'high', 'low', 'close', 'volume']
    )
    df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
    df.set_index('timestamp', inplace=True)
    
    return df


def vectorbt_rsi_strategy(close: pd.Series,
                           rsi_period: int = 14,
                           rsi_lower: float = 30,
                           rsi_upper: float = 70,
                           ema_fast: int = 12,
                           ema_slow: int = 26) -> vbt.Portfolio:
    """
    RSI + EMA 크로스오버 VectorBT 전략
    - RSI가 lower_band 하향 돌파 시 매수
    - EMA 크로스오버 또는 RSI가 upper_band 상향 돌파 시 매도
    """
    
    # RSI 계산
    delta = close.diff()
    gain = (delta.where(delta > 0, 0)).rolling(window=rsi_period).mean()
    loss = (-delta.where(delta < 0, 0)).rolling(window=rsi_period).mean()
    rs = gain / loss
    rsi = 100 - (100 / (1 + rs))
    
    # EMA 계산
    ema_fast_line = close.ewm(span=ema_fast, adjust=False).mean()
    ema_slow_line = close.ewm(span=ema_slow, adjust=False).mean()
    
    # 시그널 생성
    entries = (
        (rsi < rsi_lower) & 
        (close > ema_fast_line)
    )
    
    exits = (
        (rsi > rsi_upper) | 
        (ema_fast_line < ema_slow_line)
    )
    
    # 포트폴리오 시뮬레이션
    pf = vbt.Portfolio.from_signals(
        close=close,
        entries=entries,
        exits=exits,
        fees=0.0004,  # 0.04% 거래 수수료
        slippage=0.0005,  # 0.05% 슬리피지
        size_type='percent',
        size=0.2,  # 20% 투자
        freq='1h'
    )
    
    return pf


def run_vectorbt_optimization():
    """VectorBT 파라미터 최적화 실행"""
    
    print("=" * 60)
    print("VectorBT 高速 백테스트 & 파라미터 최적화")
    print("=" * 60)
    
    # HolySheep AI 클라이언트
    ai_client = HolySheepAIClient(api_key="YOUR_HOLYSHEEP_API_KEY")
    
    # 데이터 가져오기
    print("\n[1/5] Binance에서 BTC-USDT永续契約 데이터 가져오는 중...")
    df = fetch_crypto_data(days=180)
    close = df['close']
    
    print(f"데이터 범위: {df.index[0]} ~ {df.index[-1]}")
    print(f"총 데이터 포인트: {len(df):,}개")
    
    # AI 전략 생성 요청 (DeepSeek V3.2 사용 - $0.42/MTok)
    print("\n[2/5] HolySheep AI (DeepSeek V3.2)로 전략 최적화 중...")
    
    strategy_code = ai_client.generate_strategy_code(
        description="RSI 과매도 구간 진입 시 매수, EMA 데드크로스 시 매도하는 trend-following 전략"
    )
    
    print("생성된 전략 코드:")
    print(strategy_code[:500] + "..." if len(strategy_code) > 500 else strategy_code)
    
    # 파라미터 그리드 정의
    print("\n[3/5] 파라미터 그리드 서치 실행...")
    
    param_ranges = {
        'rsi_period': [10, 14, 21],
        'rsi_lower': [25, 30, 35],
        'rsi_upper': [65, 70, 75],
        'ema_fast': [8, 12, 21],
        'ema_slow': [21, 26, 50]
    }
    
    # VectorBT 최적화 실행
    pf_grid = vbt.Parameter(
        'rsi_period',
        param_ranges['rsi_period']
    ).grid_merge(
        vbt.Parameter('rsi_lower', param_ranges['rsi_lower']),
        vbt.Parameter('rsi_upper', param_ranges['rsi_upper']),
        vbt.Parameter('ema_fast', param_ranges['ema_fast']),
        vbt.Parameter('ema_slow', param_ranges['ema_slow'])
    )
    
    # 전체 조합 테스트 (3×3×3×3×3 = 243 조합)
    print(f"테스트 조합 수: {len(pf_grid)}개")
    
    # 최적화된 파라미터로 전략 실행
    best_pf = vectorbt_rsi_strategy(
        close=close,
        rsi_period=14,
        rsi_lower=30,
        rsi_upper=70,
        ema_fast=12,
        ema_slow=26
    )
    
    # 결과 분석
    print("\n[4/5] 결과 분석...")
    print("=" * 60)
    print("【VectorBT  백테스트 결과】")
    print("=" * 60)
    
    stats = best_pf.stats()
    print(f"총 수익률: {stats['total_return']*100:.2f}%")
    print(f"샤프 비율: {stats['sharpe_ratio']:.2f}")
    print(f"최대 드로우다운: {stats['max_drawdown']*100:.2f}%")
    print(f"총 거래 횟수: {stats['total_trades']}")
    print(f"승률: {stats['win_rate']*100:.2f}%")
    print(f"평균 보유 기간: {stats['avg_holding_duration']}")
    
    # 최적 파라미터 조합 탐색
    print("\n[5/5] 최적 파라미터 탐색...")
    
    # 여러 파라미터 조합 테스트
    results = []
    for rsi_p in param_ranges['rsi_period']:
        for rsi_l in param_ranges['rsi_lower']:
            for rsi_u in param_ranges['rsi_upper']:
                if rsi_l >= rsi_u:
                    continue
                    
                pf =

관련 리소스
관련 문서