ML 기반 전략 모듈 (ml_strategies.py)

개요

quant_strategies/ml_strategies.py는 머신러닝 기반 매매 전략을 구현한 모듈입니다. 전통적인 기술적 분석을 넘어 ML/DL 기법을 활용한 5가지 전략을 제공합니다.

목차

1. MLEnsembleStrategy
2. RegimeSwitchingStrategy
3. DeepLearningStrategy
4. ReinforcementLearningStrategy
5. AlternativeDataStrategy
6. 사용 예제

1. MLEnsembleStrategy

개념

여러 머신러닝 모델(Random Forest, XGBoost, LightGBM)의 예측을 결합하여 더 안정적인 신호를 생성하는 앙상블 전략입니다.

파라미터

생성되는 피처

┌─────────────────────────────────────────────────────────────┐
│                    Feature Engineering                       │
├─────────────────────────────────────────────────────────────┤
│  가격 피처 (Price Features)                                  │
│  ├── return_5, return_10, return_20, return_60             │
│  └── ma_ratio_5, ma_ratio_10, ma_ratio_20, ma_ratio_60     │
│                                                             │
│  변동성 피처 (Volatility Features)                          │
│  └── vol_10, vol_20, vol_60                                │
│                                                             │
│  기술적 지표 (Technical Indicators)                         │
│  ├── RSI (14일)                                            │
│  ├── MACD (12-26 EMA)                                      │
│  └── Bollinger Position (20일)                             │
│                                                             │
│  거래량 피처 (Volume Features)                              │
│  └── volume_ratio (현재/20일 평균)                         │
└─────────────────────────────────────────────────────────────┘

신호 생성 로직

1. 피처 생성 (약 15개)
2. 타겟 변수 생성 (다음날 수익률 방향: +1, -1)
3. 학습/테스트 분할 (80/20)
4. Random Forest 모델 학습
5. 예측값을 신호로 변환 (+1=매수, -1=매도)

코드 예제

from quant_strategies.ml_strategies import MLEnsembleStrategy

strategy = MLEnsembleStrategy(
    model_types=["rf", "xgb"],
    lookback=252,
    retrain_frequency=21,
)

df_with_signals = strategy.generate_signals(df)

2. RegimeSwitchingStrategy

개념

르네상스 테크놀로지(Renaissance Technologies) 스타일의 레짐 전환 전략입니다. 시장 상태(레짐)를 탐지하고, 각 레짐에 맞는 다른 전략을 적용합니다.

레짐 분류

┌─────────────────────────────────────────────────────────────┐
│                     Market Regimes                          │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  🟢 BULL (상승장)                                           │
│     조건: 추세 > 5% AND 변동성 비율 < 1.2                   │
│     전략: 모멘텀 추종 (20일 수익률 방향)                    │
│                                                             │
│  🔴 BEAR (하락장)                                           │
│     조건: 추세 < -5% AND 변동성 비율 > 1.2                  │
│     전략: 평균 회귀 (Z-score 반대 방향)                     │
│                                                             │
│  ⚪ NEUTRAL (횡보장)                                        │
│     조건: 위 조건에 해당하지 않음                           │
│     전략: 약한 모멘텀 (포지션 50% 축소)                     │
│                                                             │
└─────────────────────────────────────────────────────────────┘

파라미터

레짐 탐지 로직

# 추세 지표: 현재가 / 60일 이동평균 - 1
trend = price / MA_60 - 1

# 변동성 비율: 현재 변동성 / 평균 변동성
vol_ratio = 20일_변동성 / 60일_평균_변동성

# 분류
if trend > 0.05 and vol_ratio < 1.2:
    regime = "bull"      # 모멘텀 전략
elif trend < -0.05 and vol_ratio > 1.2:
    regime = "bear"      # 평균회귀 전략
else:
    regime = "neutral"   # 축소 포지션

코드 예제

from quant_strategies.ml_strategies import RegimeSwitchingStrategy

strategy = RegimeSwitchingStrategy(
    n_regimes=3,
    vol_lookback=20,
    trend_lookback=60,
)

df_with_signals = strategy.generate_signals(df)
print(df[["date", "close", "regime", "signal"]].tail(10))

3. DeepLearningStrategy

개념

LSTM/Transformer를 사용한 시계열 예측 전략입니다. 현재는 플레이스홀더로 구현되어 있으며, 실제 사용시 PyTorch/TensorFlow 필요합니다.

파라미터

현재 구현 (대체 로직)

딥러닝 모델 없이 다중 시간 프레임 모멘텀을 결합:

신호 = 0.5 × sign(5일 모멘텀)
     + 0.3 × sign(10일 모멘텀)
     + 0.2 × sign(20일 모멘텀)

실제 구현시 구조 (예시)

┌─────────────────────────────────────────────────────────────┐
│                    LSTM Architecture                         │
├─────────────────────────────────────────────────────────────┤
│  Input: (batch, 60, features)                               │
│     ↓                                                       │
│  LSTM Layer 1: hidden_size=128                              │
│     ↓                                                       │
│  LSTM Layer 2: hidden_size=64                               │
│     ↓                                                       │
│  Dropout: 0.2                                               │
│     ↓                                                       │
│  Dense: 32 → ReLU                                           │
│     ↓                                                       │
│  Output: 3 (매수/홀드/매도 확률)                            │
└─────────────────────────────────────────────────────────────┘

코드 예제

from quant_strategies.ml_strategies import DeepLearningStrategy

strategy = DeepLearningStrategy(sequence_length=60)
df_with_signals = strategy.generate_signals(df)

4. ReinforcementLearningStrategy

개념

강화학습(RL) 에이전트가 상태를 관찰하고 최적의 액션(매수/매도/홀드)을 선택하는 전략입니다. 현재는 플레이스홀더로 구현되어 있습니다.

파라미터

현재 구현 (대체 로직)

리스크 조정 모멘텀을 사용:

# 리스크 조정 모멘텀 = 평균 수익률 / 변동성
risk_adjusted_mom = returns.rolling(20).mean() / volatility

# 신호 생성 (-1 ~ +1 범위로 클리핑)
signal = clip(risk_adjusted_mom × 5, -1, 1)

실제 구현시 구조 (예시)

┌─────────────────────────────────────────────────────────────┐
│                  RL Agent (DQN/PPO)                         │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  State (상태):                                              │
│  ├── 가격 수익률 (5, 10, 20일)                             │
│  ├── 변동성 (10, 20일)                                     │
│  ├── RSI, MACD                                             │
│  ├── 현재 포지션                                           │
│  └── 미실현 손익                                           │
│                                                             │
│  Action (행동):                                             │
│  ├── 0: 매도 (Short)                                       │
│  ├── 1: 홀드 (Hold)                                        │
│  └── 2: 매수 (Long)                                        │
│                                                             │
│  Reward (보상):                                             │
│  └── 포지션 × 일일 수익률 - 거래비용                       │
│                                                             │
└─────────────────────────────────────────────────────────────┘

코드 예제

from quant_strategies.ml_strategies import ReinforcementLearningStrategy

strategy = ReinforcementLearningStrategy(state_features=10)
df_with_signals = strategy.generate_signals(df)

5. AlternativeDataStrategy

개념

Two Sigma 스타일의 대안 데이터(Alternative Data) 활용 전략입니다. 뉴스 센티먼트, 소셜 미디어, 위성 이미지 등 비전통적 데이터를 사용합니다.

파라미터

대안 데이터 종류 (실제 구현시)

┌─────────────────────────────────────────────────────────────┐
│                  Alternative Data Sources                    │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  📰 뉴스 센티먼트                                           │
│     └── NLP로 뉴스 기사 긍정/부정 분석                     │
│                                                             │
│  🐦 소셜 미디어                                             │
│     └── Twitter, Reddit 언급량 및 감정                     │
│                                                             │
│  🛰️ 위성 데이터                                             │
│     └── 주차장 차량 수, 물류 활동량                        │
│                                                             │
│  💳 신용카드 데이터                                         │
│     └── 소비 패턴 변화                                     │
│                                                             │
│  🌐 웹 트래픽                                               │
│     └── 기업 웹사이트 방문자 추이                          │
│                                                             │
└─────────────────────────────────────────────────────────────┘

현재 구현 (프록시 사용)

실제 대안 데이터 없이 거래량 변화를 센티먼트 프록시로 사용:

# 가격 신호: 20일 모멘텀 방향
price_signal = sign(momentum_20)

# 센티먼트 프록시: 거래량 증가 + 가격 상승 = 긍정적
sentiment_proxy = sign(volume_change_5 × momentum)

# 최종 신호
signal = price_weight × price_signal + sentiment_weight × sentiment_proxy

코드 예제

from quant_strategies.ml_strategies import AlternativeDataStrategy

strategy = AlternativeDataStrategy(
    sentiment_weight=0.6,
    price_weight=0.4,
)

df_with_signals = strategy.generate_signals(df)

6. 사용 예제

기본 사용법

import sys
sys.path.insert(0, '/path/to/trading_system')

from data.collector import DataCollector
from quant_strategies.ml_strategies import (
    MLEnsembleStrategy,
    RegimeSwitchingStrategy,
    DeepLearningStrategy,
    ReinforcementLearningStrategy,
    AlternativeDataStrategy,
)
from backtesting.engine import BacktestEngine

# 데이터 수집
collector = DataCollector()
df = collector.get_stock_data("005930", "2022-01-01", "2024-01-01")

# 전략 선택
strategy = RegimeSwitchingStrategy(
    n_regimes=3,
    vol_lookback=20,
    trend_lookback=60,
)

# 백테스트
engine = BacktestEngine(initial_capital=10_000_000)
result = engine.run(strategy, df)

print(f"총 수익률: {result.total_return:.2f}%")
print(f"샤프 비율: {result.metrics.get('sharpe_ratio', 0):.2f}")

전략 비교

strategies = [
    MLEnsembleStrategy(),
    RegimeSwitchingStrategy(),
    DeepLearningStrategy(),
    ReinforcementLearningStrategy(),
    AlternativeDataStrategy(),
]

results = {}
for strategy in strategies:
    result = engine.run(strategy, df)
    results[strategy.name] = {
        "return": result.total_return,
        "sharpe": result.metrics.get("sharpe_ratio", 0),
        "mdd": result.metrics.get("max_drawdown", 0),
    }

# 결과 출력
import pandas as pd
comparison = pd.DataFrame(results).T
print(comparison)

Walk-Forward 검증과 함께 사용

from ml.walk_forward import WalkForwardValidator

validator = WalkForwardValidator(
    train_size=252,
    val_size=63,
    test_size=63,
)

strategy = MLEnsembleStrategy()
wf_result = validator.validate(strategy, df)

print(f"강건성 점수: {wf_result.robustness_score:.2f}")
print(f"과적합 여부: {wf_result.is_overfit}")

요약 비교표

확장 방법

DeepLearning 실제 구현

# PyTorch 설치 필요
# pip install torch

import torch
import torch.nn as nn

class LSTMPredictor(nn.Module):
    def __init__(self, input_size, hidden_size=64, num_layers=2):
        super().__init__()
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, 3)  # 매수/홀드/매도

    def forward(self, x):
        lstm_out, _ = self.lstm(x)
        return self.fc(lstm_out[:, -1, :])

ReinforcementLearning 실제 구현

# Stable Baselines3 설치 필요
# pip install stable-baselines3

from stable_baselines3 import PPO
from gymnasium import Env

class TradingEnv(Env):
    def __init__(self, df):
        self.df = df
        self.action_space = ...
        self.observation_space = ...

    def step(self, action):
        # 거래 실행, 보상 계산
        pass

    def reset(self):
        # 환경 초기화
        pass

참고 자료

• Random Forest for Trading
• Regime Detection in Markets
• LSTM for Stock Prediction
• Reinforcement Learning for Trading
• Alternative Data in Finance