퀀트 트레이딩에서 백테스팅 속도는 전략 개발의 핵심 요소입니다. VectorBT는 NumPy 기반 벡터화 연산을 통해 기존 펜딩 기반 백테스팅 도구보다 수십 배 빠른 성능을 제공합니다. 본 가이드에서는 VectorBT의 성능을 극대화하는 고급 기법과 HolySheep AI를 활용한智能化 전략 최적화 방법을详하게 설명합니다.
HolySheep AI vs 공식 API vs 기타 릴레이 서비스 비교
| 비교 항목 | HolySheep AI | 공식 OpenAI API | 기타 릴레이 서비스 |
|---|---|---|---|
| GPT-4.1 가격 | $8.00/MTok | $15.00/MTok | $10-12/MTok |
| Claude Sonnet 4 | $4.50/MTok | $8.00/MTok | $6-7/MTok |
| Gemini 2.5 Flash | $2.50/MTok | $2.50/MTok | $2.80/MTok |
| DeepSeek V3.2 | $0.42/MTok | 지원 안함 | $0.50/MTok |
| 결제 방식 | 해외 신용카드 불필요, 로컬 결제 | 해외 신용카드 필수 | 다양함 (제한적) |
| API 호환성 | OpenAI 호환 구조 | 네이티브 | 부분 호환 |
| 모델 통합 | 20+ 모델 단일 키 | OpenAI 모델만 | 제한적 |
| 무료 크레딧 | 가입 시 제공 | $5 초기 크레딧 | 다양함 |
VectorBT란?
VectorBT는 Python으로 작성된高性能 벡터화 백테스팅 라이브러리입니다. 기존 백테스팅 도구와의 핵심 차이점은 다음과 같습니다:
- 완전 벡터화: 루프 대신 NumPy 벡터 연산 사용으로 수십 배 빠른 실행
- Numba JIT 컴파일: 핵심 경로에 Numba를 적용하여 추가 가속
- 메모리 효율성: pandas 대신 NumPy 배열 직접 처리
- 유연한 포트폴리오 시뮬레이션: 복잡한 거래 규칙 및 수수료 모델 지원
이런 팀에 적합 / 비적용
✅ 이런 팀에 적합
- 퀀트 연구팀: 수백 개 전략을 빠르게 테스트해야 하는 환경
- Algo 트레이딩 스타트업: 아이디어에서 프로덕션까지 빠른 반복 필요
- 개인 트레이더: 복잡한 전략을 개인 환경에서 백테스트하고 싶은 경우
- 금융 데이터 사이언스팀: Machine Learning과 결합한 전략 개발
- HolySheep AI 활용자: AI 기반 전략 최적화를低成本로 수행하려는 경우
❌ 이런 팀에는 비적합
- 고주파 트레이딩(HFT): 시뮬레이션 지연이 실제 거래와 다름
- 브로커 API 직접 연동 필요: VectorBT는 백테스트 전용
- 복잡한 시장 미세 구조 모델링: 슬리피지,流动性 제한 등 상세 모델 필요 시
- 팀 레거시 시스템: 기존 C++/Java 백테스팅 시스템과 통합 필요 시
가격과 ROI
VectorBT 비용 구조
| 항목 | 비용 | 비고 |
|---|---|---|
| VectorBT Community | 무료 (오픈소스) | 기본 기능, 단일-thread |
| VectorBT Pro | 문의 필요 | 병렬 처리, 클라우드 지원 |
| 호스팅 비용 | $20-200/월 | 데이터 저장, 컴퓨팅 자원 |
| 데이터 비용 | $10-100/월 | 야후 Finance,Polygon 등 |
AI 전략 최적화 비용 (HolySheep AI 활용)
| 작업 | HolySheep AI 비용 | 공식 API 비용 | 절감율 |
|---|---|---|---|
| 100회 파라미터 최적화 | $0.42 (DeepSeek V3) | $1.50 (동일 작업) | 72% 절감 |
| 1,000회 전략 생성 | $4.20 | $15.00 | 72% 절감 |
| 월간 AI 활용 (500K 토큰) | $12.50 | $45.00 | 72% 절감 |
왜 HolySheep를 선택해야 하나
1. 비용 효율성
퀀트 트레이딩에서 AI 활용의 가장 큰 진입장벽은 비용입니다. HolySheep AI는 DeepSeek V3.2를 $0.42/MTok이라는最低가로 제공하여:
- 수천 번의 파라미터 스캔을低成本로 수행 가능
- ML 기반 전략 최적화를 일상적으로 활용 가능
- 팀 전체가 제한 없이 AI 도구 활용 가능
2. 단일 API 키 통합
# HolySheep AI - 모든 모델을 하나의 API 키로
import openai
client = openai.OpenAI(
api_key="YOUR_HOLYSHEEP_API_KEY",
base_url="https://api.holysheep.ai/v1"
)
전략 최적화를 위한 파라미터 생성
response = client.chat.completions.create(
model="deepseek/deepseek-chat-v3-0324",
messages=[{"role": "user", "content": "RSI 기반 매매 전략의 최적 파라미터를 생성해주세요"}]
)
3. 해외 신용카드 불필요
금융 데이터 사이언스 연구자 대부분이 해외 결제 수단 접근에 어려움을 겪습니다. HolySheep AI는 한국 내 Local 결제 옵션을 제공하여:
- 신용카드 번호 입력 불필요
- 원화 결제 지원
- 가족/법인 카드 사용 가능
VectorBT 성능 최적화 핵심 기법
1. 기본 벡터화 백테스트 설정
import numpy as np
import pandas as pd
import vectorbt as vbt
from numba import njit
import warnings
warnings.filterwarnings('ignore')
HolySheep AI API 키 설정
import openai
ai_client = openai.OpenAI(
api_key="YOUR_HOLYSHEEP_API_KEY",
base_url="https://api.holysheep.ai/v1"
)
def download_and_prepare_data(symbols, start, end):
"""야후 Finance에서 데이터 다운로드 및 전처리"""
data = vbt.YFData.download(
symbols,
start=start,
end=end,
missing_index='drop'
)
return data.get('Close')
def calculate_rsi_vect(close, period=14):
"""벡터화된 RSI 계산 - 루프 없이 NumPy 연산"""
delta = np.diff(close, prepend=np.nan), axis=0
gain = np.where(delta > 0, delta, 0)
loss = np.where(delta < 0, -delta, 0)
# 지수 이동평균 사용 (빠른 계산)
avg_gain = pd.DataFrame(gain).ewm(span=period).mean().values
avg_loss = pd.DataFrame(loss).ewm(span=period).mean().values
rs = avg_gain / (avg_loss + 1e-10)
rsi = 100 - (100 / (1 + rs))
return rsi
def vectorized_bollinger_strategy(close, window=20, num_std=2):
"""볼린저밴드 벡터화 전략"""
sma = pd.DataFrame(close).rolling(window).mean().values
std = pd.DataFrame(close).rolling(window).std().values
upper = sma + num_std * std
lower = sma - num_std * std
entries = close > upper
exits = close < sma
return entries, exits
def optimize_strategy_parameters(ai_client, strategy_type, market_data):
"""HolySheep AI를 활용한 전략 파라미터 최적화 추천"""
prompt = f"""
{strategy_type} 기반 트레이딩 전략의 최적 파라미터를 제안해주세요.
시장 데이터 통계: {market_data.describe().to_dict()}
다음 형식으로 응답해주세요:
- 주요 파라미터: [값]
- 예상 수익률 범위: [%]
- 위험도: [높음/중간/낮음]
"""
response = ai_client.chat.completions.create(
model="deepseek/deepseek-chat-v3-0324",
messages=[{"role": "user", "content": prompt}],
temperature=0.3
)
return response.choices[0].message.content
실제 백테스트 실행
print("=== VectorBT 벡터화 백테스트 시작 ===")
데이터 다운로드 (3개 종목 동시 처리)
symbols = ['AAPL', 'MSFT', 'GOOGL']
close_prices = download_and_prepare_data(symbols, '2022-01-01', '2024-01-01')
print(f"데이터 형태: {close_prices.shape}")
print(f"분석 기간: {close_prices.index[0]} ~ {close_prices.index[-1]}")
벡터화된 RSI 계산 (수초 내 완료)
rsi = calculate_rsi_vect(close_prices.values, period=14)
HolySheep AI로 파라미터 최적화 추천 받기
market_stats = pd.DataFrame(close_prices)
recommendation = optimize_strategy_parameters(
ai_client,
"RSI + 이동평균 교차",
market_stats
)
print(f"AI 추천 파라미터: {recommendation}")
2. Numba JIT 컴파일로 핵심 경로 최적화
import numpy as np
import vectorbt as vbt
from numba import njit, prange
import time
@njit(parallel=True, fastmath=True)
def numba_momentum_signal(
close_prices, # (n_symbols, n_periods)
short_window, # 단기 이동평균 창
long_window, # 장기 이동평균 창
momentum_period, # 모멘텀 계산 기간
rsi_period, # RSI 계산 기간
rsi_overbought, # RSI 과매수 구간
rsi_oversold # RSI 과매도 구간
):
"""
Numba JIT 컴파일된 복합 전략 신호 생성
- 병렬 처리: 여러 종목 동시 계산
- fastmath: 부동소수점 최적화
"""
n_symbols = close_prices.shape[0]
n_periods = close_prices.shape[1]
# 출력 배열 초기화
entries = np.zeros((n_symbols, n_periods), dtype=np.bool_)
exits = np.zeros((n_symbols, n_periods), dtype=np.bool_)
# 병렬 처리로 각 종목별 독립 계산
for sym in prange(n_symbols):
prices = close_prices[sym]
for i in range(long_window, n_periods):
# 단기/장기 이동평균
short_ma = 0.0
long_ma = 0.0
for j in range(short_window):
short_ma += prices[i - j]
for j in range(long_window):
long_ma += prices[i - j]
short_ma /= short_window
long_ma /= long_window
# RSI 계산
gain_sum = 0.0
loss_sum = 0.0
for j in range(1, rsi_period + 1):
diff = prices[i - j] - prices[i - j - 1]
if diff > 0:
gain_sum += diff
else:
loss_sum -= diff
avg_gain = gain_sum / rsi_period
avg_loss = loss_sum / rsi_period
if avg_loss < 1e-10:
rsi = 100.0
else:
rs = avg_gain / avg_loss
rsi = 100.0 - (100.0 / (1.0 + rs))
# 복합 진입/청산 조건
# 1. 골든 크로스 + RSI 과매도 확인
if short_ma > long_ma and prices[i] > prices[i-1] and rsi < rsi_oversold:
entries[sym, i] = True
# 2. 데드 크로스 + RSI 과매수 확인
if short_ma < long_ma and rsi > rsi_overbought:
exits[sym, i] = True
return entries, exits
def run_optimized_backtest(close_prices, param_grid):
"""최적화된 백테스트 실행"""
results = []
for short_w in param_grid['short_window']:
for long_w in param_grid['long_window']:
if short_w >= long_w:
continue
entries, exits = numba_momentum_signal(
close_prices.values,
short_w,
long_w,
param_grid['momentum_period'],
param_grid['rsi_period'],
param_grid['rsi_overbought'],
param_grid['rsi_oversold']
)
# VectorBT 포트폴리오 시뮬레이션
pf = vbt.Portfolio.from_signals(
close_prices,
entries=entries,
exits=exits,
init_cash=10000,
fees=0.001,
slippage=0.0005
)
results.append({
'short_window': short_w,
'long_window': long_w,
'total_return': pf.total_return().mean(),
'sharpe_ratio': pf.sharpe_ratio().mean(),
'max_drawdown': pf.max_drawdown().mean(),
'win_rate': (pf.trades.win_rate().mean() if len(pf.trades) > 0 else 0)
})
return pd.DataFrame(results)
실행 예제
print("=== Numba JIT 최적화 백테스트 ===")
파라미터 그리드 설정
param_grid = {
'short_window': [5, 10, 15, 20, 25],
'long_window': [20, 30, 50, 70, 100],
'momentum_period': 14,
'rsi_period': 14,
'rsi_overbought': 70,
'rsi_oversold': 30
}
전체 파라미터 조합 수: 5 * 5 = 25개
total_combinations = len(param_grid['short_window']) * len(param_grid['long_window'])
print(f"총 파라미터 조합: {total_combinations}개")
백테스트 실행 및 시간 측정
start_time = time.time()
close_prices = vbt.YFData.download(
['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA'],
start='2020-01-01',
end='2024-01-01'
).get('Close')
results_df = run_optimized_backtest(close_prices, param_grid)
elapsed = time.time() - start_time
print(f"실행 시간: {elapsed:.2f}초")
print(f"초당 처리: {total_combinations / elapsed:.1f} 조합/초")
최적 파라미터 출력
best_params = results_df.loc[results_df['sharpe_ratio'].idxmax()]
print(f"\n최적 파라미터:")
print(f" 단기 창: {int(best_params['short_window'])}")
print(f" 장기 창: {int(best_params['long_window'])}")
print(f" 샤프 비율: {best_params['sharpe_ratio']:.3f}")
print(f" 최대 드로우다운: {best_params['max_drawdown']:.2%}")
3. GPU 가속 (CuPy 활용)
import cupy as cp
import numpy as np
import vectorbt as vbt
from numba import cuda
import time
@cuda.jit
def cuda_rolling_window_kernel(close, window, output, n_symbols, n_periods):
"""CUDA 커널: 롤링 윈도우 연산"""
idx = cuda.blockIdx.x * cuda.blockDim.x + cuda.threadIdx.x
if idx >= n_symbols * (n_periods - window + 1):
return
sym = idx // (n_periods - window + 1)
pos = idx % (n_periods - window + 1)
if sym < n_symbols and pos < n_periods - window + 1:
total = 0.0
for i in range(window):
total += close[sym, pos + i]
output[sym, pos] = total / window
def gpu_vectorized_strategy(close_prices, windows=[5, 10, 20, 50]):
"""GPU 가속 벡터화 전략"""
# NumPy → CuPy 배열 변환
close_gpu = cp.asarray(close_prices.values)
n_symbols, n_periods = close_gpu.shape
# 결과를 저장할 GPU 배열
ma_results = {}
for window in windows:
ma_gpu = cp.zeros((n_symbols, n_periods - window + 1))
# CUDA 커널 실행
threads_per_block = 256
blocks = (n_symbols * (n_periods - window + 1) + threads_per_block - 1) // threads_per_block
cuda_rolling_window_kernel[blocks, threads_per_block](
close_gpu, window, ma_gpu, n_symbols, n_periods
)
# GPU → CPU 복원 및 저장
ma_results[window] = cp.asnumpy(ma_gpu)
return ma_results
def hybrid_backtest_pipeline(close_prices, strategy_func='momentum'):
"""
하이브리드 백테스트: CPU + GPU协同 처리
- GPU: 무거운 수치 연산
- CPU: 로직 처리 및 포트폴리오 시뮬레이션
"""
print("=== GPU 가속 하이브리드 백테스트 ===")
# 1단계: GPU에서 이동평균 계산
start_gpu = time.time()
ma_data = gpu_vectorized_strategy(close_prices, windows=[5, 10, 20, 50, 100, 200])
gpu_time = time.time() - start_gpu
print(f"GPU 연산 시간: {gpu_time*1000:.1f}ms")
# 2단계: CPU에서 신호 생성 및 포트폴리오 시뮬레이션
start_cpu = time.time()
short_ma = ma_data[10] # 10일 이동평균
long_ma = ma_data[50] # 50일 이동평균
# 골든/데드 크로스 신호
diff_len = short_ma.shape[1] - long_ma.shape[1]
entries = short_ma[:, diff_len:] > long_ma
exits = short_ma[:, diff_len:] < long_ma
# VectorBT 포트폴리오
pf = vbt.Portfolio.from_signals(
close_prices.iloc[:, :entries.shape[0]],
entries=entries,
exits=exits,
init_cash=10000,
fees=0.001
)
cpu_time = time.time() - start_cpu
print(f"CPU 연산 시간: {cpu_time*1000:.1f}ms")
return pf, {
'gpu_time_ms': gpu_time * 1000,
'cpu_time_ms': cpu_time * 1000,
'total_return': pf.total_return().mean(),
'sharpe': pf.sharpe_ratio().mean()
}
실행
print("GPU 가속 백테스트 시작...")
pf, metrics = hybrid_backtest_pipeline(
vbt.YFData.download(['AAPL', 'MSFT', 'GOOGL']).get('Close')
)
print(f"결과: 총 수익률 {metrics['total_return']:.2%}, 샤프 비율 {metrics['sharpe']:.2f}")
HolySheep AI와 결합한智能化 전략 최적화
import openai
import json
import pandas as pd
import numpy as np
import vectorbt as vbt
from typing import Dict, List, Tuple
class AIStrategyOptimizer:
"""HolySheep AI 기반 자동 전략 최적화기"""
def __init__(self, api_key: str):
self.client = openai.OpenAI(
api_key=api_key,
base_url="https://api.holysheep.ai/v1"
)
self.model = "deepseek/deepseek-chat-v3-0324" # 가장 비용 효율적
def analyze_market_regime(self, close_prices: pd.DataFrame) -> Dict:
"""시장 상황 분석 및 regime 분류"""
returns = close_prices.pct_change().dropna()
prompt = f"""
다음 시장 데이터의 통계를 분석하여 현재 시장 Regime을 분류해주세요.
수익률 통계:
- 평균 수익률: {returns.mean().mean():.4f}
- 변동성: {returns.std().mean():.4f}
- 최대 수익: {returns.max().max():.4f}
- 최대 손실: {returns.min().min():.4f}
Regime 옵션: 강한 상승, 약한 상승, 박스권, 약한 하락, 강한 하락
응답 형식: {{"regime": "선택", "적합_strategy": ["전략1", "전략2"], "주의사항": "..."}}
"""
response = self.client.chat.completions.create(
model=self.model,
messages=[{"role": "user", "content": prompt}],
temperature=0.3
)
return json.loads(response.choices[0].message.content)
def generate_parameter_suggestions(
self,
base_strategy: str,
market_regime: str,
param_bounds: Dict[str, Tuple[float, float]]
) -> List[Dict]:
"""AI 기반 파라미터 범위 제안 생성"""
prompt = f"""
{base_strategy} 전략의 최적 파라미터를 {param_bounds} 범위 내에서 제안해주세요.
현재 시장 Regime: {market_regime}
{len(param_bounds) * 3}개의 파라미터 조합을 생성해주세요.
응답 형식: [{{"param1": 값, "param2": 값}}, ...]
"""
response = self.client.chat.completions.create(
model=self.model,
messages=[{"role": "user", "content": prompt}],
temperature=0.5
)
return json.loads(response.choices[0].message.content)
def optimize_strategy(
self,
close_prices: pd.DataFrame,
strategy_type: str,
max_iterations: int = 50
) -> Dict:
"""완전한 전략 최적화 파이프라인"""
print(f"=== AI 전략 최적화 시작 ({strategy_type}) ===")
# 1단계: 시장 Regime 분석
print("1단계: 시장 Regime 분석...")
regime_analysis = self.analyze_market_regime(close_prices)
print(f" 분석 결과: {regime_analysis}")
# 2단계: AI 파라미터 제안
print("2단계: AI 파라미터 제안...")
param_bounds = {
'rsi_period': (7, 21),
'rsi_overbought': (60, 80),
'rsi_oversold': (20, 40),
'ma_short': (5, 30),
'ma_long': (30, 200)
}
suggestions = self.generate_parameter_suggestions(
strategy_type,
regime_analysis['regime'],
param_bounds
)
print(f" {len(suggestions)}개 파라미터 조합 제안 받음")
# 3단계: 백테스트 실행
print("3단계: 백테스트 실행...")
results = []
for i, params in enumerate(suggestions[:max_iterations]):
try:
# RSI 계산
delta = close_prices.diff()
gain = delta.where(delta > 0, 0).rolling(params.get('rsi_period', 14)).mean()
loss = (-delta.where(delta < 0, 0)).rolling(params.get('rsi_period', 14)).mean()
rs = gain / (loss + 1e-10)
rsi = 100 - (100 / (1 + rs))
# 신호 생성
entries = rsi < params.get('rsi_oversold', 30)
exits = rsi > params.get('rsi_overbought', 70)
# 포트폴리오 시뮬레이션
pf = vbt.Portfolio.from_signals(
close_prices,
entries=entries,
exits=exits,
init_cash=10000,
fees=0.001
)
results.append({
'params': params,
'total_return': pf.total_return().mean(),
'sharpe_ratio': pf.sharpe_ratio().mean(),
'max_drawdown': pf.max_drawdown().mean(),
'win_rate': len(pf.trades) > 0 and pf.trades.win_rate().mean() or 0
})
print(f" [{i+1}/{len(suggestions[:max_iterations])}] "
f"샤프: {results[-1]['sharpe_ratio']:.3f}, "
f"수익률: {results[-1]['total_return']:.2%}")
except Exception as e:
print(f" [{i+1}] 오류: {str(e)}")
continue
# 4단계: 최적 결과 도출
print("4단계: 최적 결과 도출...")
results_df = pd.DataFrame(results)
best_idx = results_df['sharpe_ratio'].idxmax()
best_result = results_df.loc[best_idx]
return {
'best_params': best_result['params'],
'best_sharpe': best_result['sharpe_ratio'],
'best_return': best_result['total_return'],
'best_drawdown': best_result['max_drawdown'],
'all_results': results_df,
'regime': regime_analysis
}
실행 예제
print("=== HolySheep AI 전략 최적화 데모 ===\n")
optimizer = AIStrategyOptimizer("YOUR_HOLYSHEEP_API_KEY")
데이터 로드
close_prices = vbt.YFData.download(
['AAPL', 'MSFT', 'GOOGL'],
start='2022-01-01',
end='2024-01-01'
).get('Close')
최적화 실행
optimization_result = optimizer.optimize_strategy(
close_prices,
strategy_type='RSI + 모멘텀',
max_iterations=20
)
print(f"\n=== 최적화 결과 ===")
print(f"최적 파라미터: {optimization_result['best_params']}")
print(f"최대 샤프 비율: {optimization_result['best_sharpe']:.3f}")
print(f"예상 수익률: {optimization_result['best_return']:.2%}")
print(f"최대 드로우다운: {optimization_result['best_drawdown']:.2%}")
print(f"시장 Regime: {optimization_result['regime']}")
토큰 사용량 확인 (비용 최적화를 위해)
print(f"\n※ 참고: HolySheep AI DeepSeek V3.2 사용 시 약 $0.42/MTok으로,")
print(f" 동일 작업을 공식 OpenAI API 대비 72% 비용 절감 가능")
자주 발생하는 오류와 해결책
오류 1: VectorBT 데이터 다운로드 실패
# ❌ 오류 발생 코드
import vectorbt as vbt
data = vbt.YFData.download('INVALID_SYMBOL_123')
close = data.get('Close') # None 반환 또는 에러
✅ 해결책: 심볼 검증 및 대안 데이터 소스
import vectorbt as vbt
from yfinance import Ticker
import pandas as pd
def safe_download_data(symbols, start, end):
"""안전한 데이터 다운로드 with 검증"""
valid_symbols = []
invalid_symbols = []
for symbol in symbols:
try:
# 심볼 유효성 사전 검증
ticker = Ticker(symbol)
info = ticker.info
if 'regularMarketPrice' in info or 'currentPrice' in info:
valid_symbols.append(symbol)
else:
invalid_symbols.append(symbol)
except Exception as e:
invalid_symbols.append(symbol)
print(f"심볼 {symbol} 검증 실패: {str(e)[:50]}")
if invalid_symbols:
print(f"⚠️ 무효 심볼: {invalid_symbols}")
if not valid_symbols:
raise ValueError("유효한 심볼이 없습니다")
# 검증된 심볼만 다운로드
data = vbt.YFData.download(
valid_symbols,
start=start,
end=end,
missing_index='drop',
interval='1d'
)
close = data.get('Close')
# 결측치 처리
if close.isnull().any().any():
print("⚠️ 결측치 발견, 보간 처리 적용")
close = close.ffill().bfill()
return close, valid_symbols
실행
symbols = ['AAPL', 'INVALID_SYMBOL', 'GOOGL', 'MSFT123']
try:
close, valid = safe_download_data(symbols, '2023-01-01', '2024-01-01')
print(f"성공: {valid} ({len(valid)}/{len(symbols)}개)")
except ValueError as e:
print(f"데이터 다운로드 실패: {e}")
오류 2: Numba JIT 컴파일 오류
# ❌ 오류 발생 코드
from numba import njit
@njit
def bad_function(data):
result = []
for i in range(len(data)):
result.append(data[i] * 2) # Numba는 리스트 동적 확장을 지원하지 않음
return result
✅ 해결책: 미리 할당된 배열 사용
from numba import njit
import numpy as np
@njit
def good_function(data):
n = len(data)
result = np.zeros(n) # 고정 크기 배열 미리 할당
for i in range(n):
result[i] = data[i] * 2
return result
더 복잡한 예시: 2D 배열 처리
@njit
def rolling_mean_2d(data, window):
"""
2D 데이터의 각 행에 대해 롤링 평균 계산
- data: (n_symbols, n_periods)
- window: 윈도우 크기
"""
n_symbols, n_periods = data.shape
result = np.zeros((