VectorBT: 1초에 100만+ 거래를 처리하는 초고속 Python 백테스팅 라이브러리 — 2026 퀀트 가이드

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

# 데이터 가져오기 — VectorBT는 yfinance를 편의용으로 랩핑
price = vbt.YFData.download(
    "BTC-USD",
    start="2020-01-01",
    end="2026-01-01",
    interval="1d"
).get("Close")

print(f"Data shape: {price.shape}")  # (2,210,) — 일일 종가
print(f"Data type: {type(price)}")   # <class 'pandas.core.series.Series'>

# 기본 설치
pip install vectorbt

# 모든 선택적 의존성 포함 (권장)
pip install "vectorbt[all]"

import vectorbt as vbt
print(vbt.__version__)  # 0.27.2 이상

# requirements.txt
vectorbt==0.27.2
numba==0.60.0
numpy==1.26.4
pandas==2.2.3
yfinance==0.2.54
plotly==5.24.1

xcode-select --install  # Numba 설치가 실패하면 먼저 실행

import vectorbt as vbt
import pandas as pd

# 역사적 데이터 다운로드
price = vbt.YFData.download(
    ["AAPL", "MSFT", "GOOGL"],
    start="2020-01-01",
    end="2026-01-01"
).get("Close")

# 빠선과 느린선 이동평균 생성
fast_ma = vbt.MA.run(price, window=20)
slow_ma = vbt.MA.run(price, window=50)

# 진입 및 청산 신호 생성
entries = fast_ma.ma_crossed_above(slow_ma)
exits = fast_ma.ma_crossed_below(slow_ma)

# 포트폴리오 시뮬레이션 실행
portfolio = vbt.Portfolio.from_signals(
    price,
    entries=entries,
    exits=exits,
    init_cash=100_000,
    fees=0.001,        # 거래당 0.1% 수수료
    slippage=0.0005    # 5 bps 슬리피지
)

# 결과
print(portfolio.total_return())
print(portfolio.sharpe_ratio())

import vectorbt as vbt

price = vbt.YFData.download("BTC-USD", start="2020-01-01", end="2026-01-01").get("Close")

# 매개변수 범위 정의
fast_windows = np.arange(5, 51, 5)    # [5, 10, 15, ..., 50]
slow_windows = np.arange(20, 201, 10)  # [20, 30, 40, ..., 200]

# 벡터화된 그리드 서치 실행
fast_ma, slow_ma = vbt.MA.run_combs(
    price,
    window=fast_windows,
    r=2,
    short_names=["fast", "slow"]
)

entries = fast_ma.ma_crossed_above(slow_ma)
exits = fast_ma.ma_crossed_below(slow_ma)

portfolio = vbt.Portfolio.from_signals(
    price, entries=exits, exits=entries,
    init_cash=10_000, fees=0.001
)

# 최적 조합 찾기
best_idx = portfolio.sharpe_ratio().idxmax()
print(f"Best params: {best_idx}")
print(f"Sharpe: {portfolio.sharpe_ratio().loc[best_idx]:.2f}")

import vectorbt as vbt
from datetime import datetime
import pandas as pd

price = vbt.YFData.download("ETH-USD", start="2021-01-01", end="2026-01-01").get("Close")

# 워크포워드 설정
n_splits = 10
split_size = len(price) // n_splits
results = []

for i in range(n_splits):
    # 트레인/테스트 윈도우 정의
    train_start = i * split_size
    train_end = train_start + split_size - 60
    test_end = train_start + split_size
    
    train_price = price.iloc[train_start:train_end]
    test_price = price.iloc[train_end:test_end]
    
    # 트레인 세트에서 최적화
    fast_ma = vbt.MA.run(train_price, np.arange(5, 31, 5))
    slow_ma = vbt.MA.run(train_price, np.arange(20, 101, 10))
    
    entries = fast_ma.ma_crossed_above(slow_ma)
    exits = fast_ma.ma_crossed_below(slow_ma)
    
    train_pf = vbt.Portfolio.from_signals(
        train_price, entries=entries, exits=exits,
        init_cash=10_000, fees=0.001
    )
    
    best = train_pf.sharpe_ratio().idxmax()
    best_fast, best_slow = best
    
    # 샘플 외 테스트
    test_fast = vbt.MA.run(test_price, window=best_fast)
    test_slow = vbt.MA.run(test_price, window=best_slow)
    test_entries = test_fast.ma_crossed_above(test_slow)
    test_exits = test_fast.ma_crossed_below(test_slow)
    
    test_pf = vbt.Portfolio.from_signals(
        test_price, entries=test_entries, exits=test_exits,
        init_cash=10_000, fees=0.001
    )
    
    results.append({
        "split": i,
        "fast": best_fast,
        "slow": best_slow,
        "train_sharpe": train_pf.sharpe_ratio().loc[best],
        "test_sharpe": test_pf.sharpe_ratio(),
        "test_return": test_pf.total_return()
    })

results_df = pd.DataFrame(results)
print(results_df[["test_sharpe", "test_return"]].mean())

import vectorbt as vbt
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
import pandas as pd
import numpy as np

# 데이터 로드
price = vbt.YFData.download("BTC-USD", start="2020-01-01", end="2026-01-01").get("Close")
returns = price.pct_change()

# 특성 매트릭스 구축: 지연된 수익률
lags = 5
features = pd.concat([returns.shift(i) for i in range(1, lags + 1)], axis=1)
features.columns = [f"lag_{i}" for i in range(1, lags + 1)]

# 타겟: 다음 날 수익률이 양수면 1, 아니면 0
target = (returns.shift(-1) > 0).astype(int)

# 정리 및 분할
data = pd.concat([features, target], axis=1).dropna()
X = data.iloc[:, :-1]
y = data.iloc[:, -1]
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, shuffle=False
)

# 분류기 훈련
clf = RandomForestClassifier(n_estimators=200, max_depth=5, random_state=42)
clf.fit(X_train, y_train)

# 테스트 세트에서 예측 생성
predictions = pd.Series(
    clf.predict(X_test),
    index=X_test.index,
    name="prediction"
)

# 신호 생성: 상승 예측일에 진입, 하락 예측일에 청산
test_price = price.loc[X_test.index]
entries = predictions == 1
exits = predictions == 0

# ML 신호로 백테스트 실행
ml_portfolio = vbt.Portfolio.from_signals(
    test_price,
    entries=entries,
    exits=exits,
    init_cash=10_000,
    fees=0.001,
    freq="1D"
)

print(f"ML Strategy Return: {ml_portfolio.total_return():.2%}")
print(f"ML Strategy Sharpe: {ml_portfolio.sharpe_ratio():.2f}")
print(f"Buy & Hold Return: {(test_price.iloc[-1] / test_price.iloc[0] - 1):.2%}")

import vectorbt as vbt
import numpy as np

# 다중 자산 가격 데이터
data = vbt.YFData.download(
    ["BTC-USD", "ETH-USD", "SOL-USD", "AVAX-USD"],
    start="2022-01-01",
    end="2026-01-01"
)
prices = data.get("Close")

# 간단한 역-변동성 가중치
returns = prices.pct_change().dropna()
volatility = returns.rolling(30).std().iloc[-1]
weights = 1 / volatility
weights = weights / weights.sum()

print("포트폴리오 가중치:")
for symbol, w in weights.items():
    print(f"  {symbol}: {w:.2%}")

# 할당 백테스트
portfolio = vbt.Portfolio.from_holding(
    prices,
    weights=weights,
    init_cash=100_000,
    fees=0.001
)

print(f"\nCAGR: {portfolio.total_return() ** (1/4) - 1:.2%}")
print(f"Sharpe: {portfolio.sharpe_ratio():.2f}")
print(f"Max Drawdown: {portfolio.max_drawdown():.2%}")

import vectorbt as vbt
import numpy as np
from numba import njit

@njit
def custom_momentum_nb(price, period):
    """Numba 가속 모멘텀 지표."""
    momentum = np.empty_like(price)
    momentum[:period] = np.nan
    for i in range(period, len(price)):
        momentum[i] = (price[i] / price[i - period] - 1) * 100
    return momentum

# IndicatorFactory로 랩핑
CustomMomentum = vbt.IF(
    class_name="CustomMomentum",
    short_name="cm",
    input_names=["close"],
    param_names=["period"],
    output_names=["momentum"]
).with_custom_func(custom_momentum_nb)

# 사용
price = vbt.YFData.download("BTC-USD", start="2023-01-01").get("Close")
cm = CustomMomentum.run(price, period=[7, 14, 30])
print(cm.momentum)

import vectorbt as vbt

price = vbt.YFData.download("BTC-USD", start="2023-01-01").get("Close")

entries = vbt.MA.run(price, 10).ma_crossed_above(vbt.MA.run(price, 30))

portfolio = vbt.Portfolio.from_signals(
    price,
    entries=entries,
    exits=None,  # 스톱/테이크프로핏이 청산 처리
    sl_stop=0.05,     # 5% 스톱로스
    tp_stop=0.15,     # 15% 테이크프로핏
    tsl_stop=0.08,    # 8% 트레일링 스톱
    init_cash=10_000,
    fees=0.001
)

print(f"Return: {portfolio.total_return():.2%}")
print(f"Win rate: {portfolio.trades.win_rate():.2%}")
print(f"Avg trade: {portfolio.trades.returns.mean():.2%}")

from multiprocessing import Pool
import vectorbt as vbt
import numpy as np

def run_chunk(param_chunk):
    price = vbt.YFData.download("BTC-USD").get("Close")
    fast_ma = vbt.MA.run(price, param_chunk[:, 0])
    slow_ma = vbt.MA.run(price, param_chunk[:, 1])
    entries = fast_ma.ma_crossed_above(slow_ma)
    exits = fast_ma.ma_crossed_below(slow_ma)
    pf = vbt.Portfolio.from_signals(price, entries, exits, init_cash=10_000)
    return pf.sharpe_ratio()

# 360개 파라미터를 4개 프로세스로 분할
params = np.array(np.meshgrid(np.arange(5, 41, 5), np.arange(20, 121, 10))).T.reshape(-1, 2)
chunks = np.array_split(params, 4)

with Pool(4) as p:
    results = p.map(run_chunk, chunks)