diff --git a/.env.example b/.env.example index 5aa2042..6e2c7f6 100644 --- a/.env.example +++ b/.env.example @@ -8,4 +8,4 @@ DISCORD_WEBHOOK_URL= ML_THRESHOLD=0.55 MAX_SAME_DIRECTION=2 BINANCE_TESTNET_API_KEY= -BINANCE_TESTNET_API_SECRET= \ No newline at end of file +BINANCE_TESTNET_API_SECRET= diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md index 124948b..9d8f544 100644 --- a/ARCHITECTURE.md +++ b/ARCHITECTURE.md @@ -17,7 +17,22 @@ ## 1. 시스템 오버뷰 -CoinTrader는 **Binance Futures 자동매매 봇**입니다. 기술 지표 신호를 1차 필터로, LightGBM(또는 MLX 신경망) 모델을 2차 필터로 사용하여 XRPUSDT 선물 포지션을 자동 진입·청산합니다. +CoinTrader는 **Binance Futures 자동매매 봇**입니다. 기술 지표 신호를 1차 필터로, LightGBM(또는 MLX 신경망) 모델을 2차 필터로 사용하여 다중 심볼(XRP, TRX, DOGE 등) 선물 포지션을 동시에 자동 진입·청산합니다. + +### 멀티심볼 아키텍처 + +``` +main.py + └─ Config (SYMBOLS=XRPUSDT,TRXUSDT,DOGEUSDT) + └─ RiskManager (공유 싱글턴, asyncio.Lock) + └─ asyncio.gather( + TradingBot(symbol="XRPUSDT", risk=shared_risk), + TradingBot(symbol="TRXUSDT", risk=shared_risk), + TradingBot(symbol="DOGEUSDT", risk=shared_risk), + ) +``` + +각 봇은 독립적인 `Exchange`, `MLFilter`, `DataStream`을 소유합니다. `RiskManager`만 공유 싱글턴으로 글로벌 리스크(일일 손실 한도, 동일 방향 제한, 최대 포지션 수)를 관리합니다. ### 전체 데이터 파이프라인 흐름도 @@ -30,11 +45,11 @@ flowchart TD end subgraph 실시간봇["실시간 봇 (bot.py — asyncio)"] - DS["data_stream.py
MultiSymbolStream
캔들 버퍼 (deque 200개)"] + DS["data_stream.py
MultiSymbolStream (심볼별)
캔들 버퍼 (deque 200개)"] IND["indicators.py
기술 지표 계산
RSI·MACD·BB·EMA·StochRSI·ATR·ADX"] MF["ml_features.py
23개 피처 추출
(XRP 13 + BTC/ETH 8 + OI/FR 2)"] ML["ml_filter.py
MLFilter
ONNX 우선 / LightGBM 폴백
확률 ≥ 0.60 시 진입 허용"] - RM["risk_manager.py
RiskManager
일일 손실 5% 한도
동적 증거금 비율"] + RM["risk_manager.py
RiskManager (공유 싱글턴)
일일 손실 5% 한도
동적 증거금 비율
동일 방향 제한"] EX["exchange.py
BinanceFuturesClient
주문·레버리지·잔고 API"] UDS["user_data_stream.py
UserDataStream
TP/SL 즉시 감지"] NT["notifier.py
DiscordNotifier
진입·청산·오류 알림"] @@ -119,17 +134,17 @@ flowchart TD **파일:** `src/data_stream.py` -봇이 시작되면 가장 먼저 실행되는 레이어입니다. Binance Combined WebSocket 단일 연결로 XRP·BTC·ETH 3개 심볼의 15분봉 캔들을 동시에 수신합니다. +각 봇 인스턴스가 시작되면 가장 먼저 실행되는 레이어입니다. Binance Combined WebSocket 단일 연결로 주 거래 심볼 + 상관관계 심볼(BTC/ETH)의 15분봉 캔들을 동시에 수신합니다. **핵심 동작:** 1. **프리로드**: 봇 시작 시 REST API로 과거 캔들 200개를 `deque`에 즉시 채웁니다. EMA50 안정화에 필요한 최소 캔들(100개)을 확보하여 첫 캔들부터 신호를 계산할 수 있게 합니다. 2. **버퍼 관리**: 심볼별 `deque(maxlen=200)`에 마감된 캔들만 추가합니다. 미마감 캔들(`is_closed=False`)은 무시합니다. -3. **콜백 트리거**: XRP(주 심볼) 캔들이 마감되면 `bot._on_candle_closed()`를 호출합니다. BTC·ETH는 버퍼에만 쌓이고 콜백을 트리거하지 않습니다. +3. **콜백 트리거**: 주 거래 심볼 캔들이 마감되면 `bot._on_candle_closed()`를 호출합니다. 상관관계 심볼(BTC·ETH)은 버퍼에만 쌓이고 콜백을 트리거하지 않습니다. ``` -Combined WebSocket - ├── xrpusdt@kline_15m → buffers["xrpusdt"] → on_candle() 호출 +예: TRXUSDT 봇의 Combined WebSocket + ├── trxusdt@kline_15m → buffers["trxusdt"] → on_candle() 호출 ├── btcusdt@kline_15m → buffers["btcusdt"] (콜백 없음) └── ethusdt@kline_15m → buffers["ethusdt"] (콜백 없음) ``` @@ -252,11 +267,15 @@ SL/TP 주문은 `/fapi/v1/algoOrder` 엔드포인트로 전송됩니다 (일반 | 제어 항목 | 기준 | |----------|------| | 일일 최대 손실 | 기준 잔고의 5% | -| 최대 동시 포지션 | 3개 | +| 최대 동시 포지션 | 3개 (전체 심볼 합산) | +| 동일 방향 제한 | 2개 (LONG 2개면 3번째 LONG 차단) | +| 같은 심볼 중복 | 차단 (1심볼 1포지션) | | 최소 명목금액 | $5 USDT | **반대 시그널 재진입:** 보유 포지션과 반대 방향 신호 발생 시 기존 포지션을 즉시 청산하고, ML 필터 통과 시 반대 방향으로 재진입합니다. 재진입 중 User Data Stream 콜백이 신규 포지션 상태를 덮어쓰지 않도록 `_is_reentering` 플래그로 보호합니다. +**마진 균등 배분:** 멀티심볼 모드에서 각 봇은 전체 잔고를 심볼 수로 나눈 금액만큼만 사용합니다 (`balance / len(symbols)`). 공유 `RiskManager`의 `asyncio.Lock`으로 동시 포지션 등록/해제 시 경합 조건을 방지합니다. + --- ### Layer 5: Event / Alert Layer @@ -272,7 +291,7 @@ Binance `ORDER_TRADE_UPDATE` 웹소켓 이벤트를 구독하여 TP/SL 체결을 ``` 이벤트 필터링 조건: e == "ORDER_TRADE_UPDATE" - AND s == "XRPUSDT" ← 심볼 필터 + AND s == self.symbol ← 심볼 필터 (봇별 독립) AND x == "TRADE" ← 실제 체결 AND X == "FILLED" ← 완전 체결 AND (reduceOnly OR order_type in {STOP_MARKET, TAKE_PROFIT_MARKET} OR rp != 0) @@ -360,11 +379,11 @@ reg_alpha: 1e-4 ~ 1.0 (log scale) reg_lambda: 1e-4 ~ 1.0 (log scale) ``` -결과는 `models/tune_results_YYYYMMDD_HHMMSS.json`에 저장됩니다. +결과는 `models/{symbol}/tune_results_YYYYMMDD_HHMMSS.json`에 저장됩니다. #### Step 2: Active Config 패턴으로 파라미터 승인 -Optuna가 찾은 파라미터는 **자동으로 적용되지 않습니다.** 사람이 결과를 검토하고 직접 `models/active_lgbm_params.json`을 업데이트해야 합니다. +Optuna가 찾은 파라미터는 **자동으로 적용되지 않습니다.** 사람이 결과를 검토하고 직접 `models/{symbol}/active_lgbm_params.json`을 업데이트해야 합니다. ```json { @@ -390,18 +409,20 @@ Optuna가 찾은 파라미터는 **자동으로 적용되지 않습니다.** 사 `scripts/train_and_deploy.sh`는 3단계를 자동으로 실행합니다: ``` -[1/3] 데이터 수집 (fetch_history.py) - - 기존 parquet 없음 → 1년치(365일) 전체 수집 - - 기존 parquet 있음 → 35일치 Upsert (OI/펀딩비 0.0 구간 보충) +[심볼별 반복] --symbol 지정 시 단일 심볼, --all 시 전체 심볼 순차 처리 -[2/3] 모델 학습 (train_model.py) - - active_lgbm_params.json 파라미터 로드 +[1/3] 데이터 수집 (fetch_history.py --symbol {SYM}) + - data/{symbol}/combined_15m.parquet 없음 → 1년치(365일) 전체 수집 + - 있음 → 35일치 Upsert (OI/펀딩비 0.0 구간 보충) + +[2/3] 모델 학습 (train_model.py --symbol {SYM}) + - models/{symbol}/active_lgbm_params.json 파라미터 로드 - 벡터화 데이터셋 생성 (dataset_builder.py) - Walk-Forward 5폴드 검증 후 최종 모델 저장 - - 학습 로그: models/training_log.json + - 학습 로그: models/{symbol}/training_log.json -[3/3] LXC 배포 (deploy_model.sh) - - rsync로 lgbm_filter.pkl → LXC 서버 전송 +[3/3] LXC 배포 (deploy_model.sh --symbol {SYM}) + - rsync로 models/{symbol}/lgbm_filter.pkl → LXC 서버 전송 - 기존 모델 자동 백업 (lgbm_filter_prev.pkl) - ONNX 파일 충돌 방지 (우선순위 보장) ``` @@ -547,7 +568,7 @@ sequenceDiagram ### 5.1 테스트 파일 구성 -`tests/` 폴더에 12개 테스트 파일, 총 **81개의 테스트 케이스**가 작성되어 있습니다. +`tests/` 폴더에 14개 테스트 파일, 총 **99개의 테스트 케이스**가 작성되어 있습니다. ```bash pytest tests/ -v # 전체 실행 @@ -562,14 +583,14 @@ bash scripts/run_tests.sh # 래퍼 스크립트 실행 | `test_indicators.py` | `src/indicators.py` | 7 | RSI 범위(0~100), MACD 컬럼 존재, 볼린저 밴드 상하단 대소관계, 신호 반환값 유효성, ADX 컬럼 존재, ADX<25 횡보장 차단, ADX NaN 폴스루 | | `test_ml_features.py` | `src/ml_features.py` | 11 | 23개 피처 수, BTC/ETH 포함 시 피처 수, RS 분모 0 처리, NaN 없음, side 인코딩, OI/펀딩비 파라미터 반영 | | `test_ml_filter.py` | `src/ml_filter.py` | 5 | 모델 없을 때 폴백 허용, 임계값 이상/미만 판단, 핫리로드 후 상태 변화 | -| `test_risk_manager.py` | `src/risk_manager.py` | 8 | 일일 손실 한도 초과 차단, 최대 포지션 수 제한, 동적 증거금 비율 상한/하한 클램핑 | +| `test_risk_manager.py` | `src/risk_manager.py` | 13 | 일일 손실 한도 초과 차단, 최대 포지션 수 제한, 동일 방향 제한, 심볼 중복 차단, 비동기 포지션 등록/해제, 동적 증거금 비율 상한/하한 클램핑 | | `test_exchange.py` | `src/exchange.py` | 8 | 수량 계산(기본/최소명목금액/잔고0), OI·펀딩비 조회 정상/오류 시 반환값 | | `test_data_stream.py` | `src/data_stream.py` | 6 | 3심볼 버퍼 존재, 빈 버퍼 None 반환, 캔들 파싱, 마감 캔들 콜백 호출, 프리로드 200개 | | `test_label_builder.py` | `src/label_builder.py` | 4 | LONG TP 도달 → 1, LONG SL 도달 → 0, 미결 → None, SHORT TP 도달 → 1 | | `test_dataset_builder.py` | `src/dataset_builder.py` | 9 | DataFrame 반환, 필수 컬럼 존재, 레이블 이진값, BTC/ETH 포함 시 23개 피처, inf/NaN 없음, OI nan 마스킹, RS 분모 0 처리 | | `test_mlx_filter.py` | `src/mlx_filter.py` | 5 | GPU 디바이스 확인, 학습 전 예측 형태, 학습 후 유효 확률, NaN 피처 처리, 저장/로드 후 동일 예측 | | `test_fetch_history.py` | `scripts/fetch_history.py` | 5 | OI=0 구간 Upsert, 신규 행 추가, 기존 비0값 보존, 파일 없을 때 신규 반환, 타임스탬프 오름차순 정렬 | -| `test_config.py` | `src/config.py` | 2 | 환경변수 로드, 동적 증거금 파라미터 로드 | +| `test_config.py` | `src/config.py` | 6 | 환경변수 로드, 동적 증거금 파라미터 로드, `symbols` 리스트, `correlation_symbols`, `max_same_direction`, SYMBOL→symbols 폴백 | > `test_mlx_filter.py`는 Apple Silicon(`mlx` 패키지)이 없는 환경에서 자동 스킵됩니다. @@ -588,6 +609,8 @@ bash scripts/run_tests.sh # 래퍼 스크립트 실행 | 레이블 생성 (SL/TP 룩어헤드) | ✅ | ✅ | `test_label_builder` + `test_dataset_builder` (전체 파이프라인 실제 호출) | | 벡터화 데이터셋 빌더 | ✅ | ✅ | `test_dataset_builder` | | 동적 증거금 비율 계산 | ✅ | — | `test_risk_manager` | +| 동일 방향 포지션 제한 | ✅ | — | `test_risk_manager` | +| 심볼 중복 진입 차단 | ✅ | — | `test_risk_manager` | | 일일 손실 한도 제어 | ✅ | — | `test_risk_manager` | | 포지션 수량 계산 | ✅ | — | `test_exchange` | | OI/펀딩비 API 조회 (정상/오류) | ✅ | ✅ | `test_exchange` + `test_bot` (`process_candle` → OI/펀딩비 → `build_features` 전달) | @@ -622,25 +645,25 @@ bash scripts/run_tests.sh # 래퍼 스크립트 실행 | 파일 | 레이어 | 역할 | |------|--------|------| -| `main.py` | — | 진입점. `Config` 로드 후 `TradingBot.run()` 실행 | -| `src/bot.py` | 오케스트레이터 | 모든 레이어를 조율하는 메인 트레이딩 루프 | -| `src/config.py` | — | 환경변수 기반 설정 (`@dataclass`) | +| `main.py` | — | 진입점. 심볼별 `TradingBot` 생성 + 공유 `RiskManager` + `asyncio.gather()` | +| `src/bot.py` | 오케스트레이터 | 심볼별 독립 트레이딩 루프 (symbol, risk 주입) | +| `src/config.py` | — | 환경변수 기반 설정 (`symbols` 리스트, `correlation_symbols`) | | `src/data_stream.py` | Data | Combined WebSocket 캔들 수신·버퍼 관리 | | `src/indicators.py` | Signal | 기술 지표 계산 및 복합 신호 생성 | | `src/ml_features.py` | ML Filter | 23개 ML 피처 추출 | | `src/ml_filter.py` | ML Filter | ONNX/LightGBM 모델 로드·추론·핫리로드 | | `src/mlx_filter.py` | ML Filter | Apple Silicon GPU 학습 + ONNX export | -| `src/exchange.py` | Execution | Binance Futures REST API 클라이언트 | -| `src/risk_manager.py` | Risk | 일일 손실 한도·동적 증거금 비율·포지션 수 제어 | +| `src/exchange.py` | Execution | Binance Futures REST API 클라이언트 (심볼별 독립) | +| `src/risk_manager.py` | Risk | 공유 싱글턴 — 일일 손실 한도·동일 방향 제한·동적 증거금 비율 | | `src/user_data_stream.py` | Event | User Data Stream TP/SL 즉시 감지 | | `src/notifier.py` | Alert | Discord 웹훅 알림 | | `src/label_builder.py` | MLOps | 학습 레이블 생성 (ATR SL/TP 룩어헤드) | | `src/dataset_builder.py` | MLOps | 벡터화 데이터셋 빌더 (학습용) | | `src/logger_setup.py` | — | Loguru 로거 설정 | -| `scripts/fetch_history.py` | MLOps | 과거 캔들 + OI/펀딩비 수집 (Parquet Upsert) | -| `scripts/train_model.py` | MLOps | LightGBM 모델 학습 (CPU) | +| `scripts/fetch_history.py` | MLOps | 과거 캔들 + OI/펀딩비 수집 (`--symbol` 지원) | +| `scripts/train_model.py` | MLOps | LightGBM 모델 학습 (`--symbol` 지원) | | `scripts/train_mlx_model.py` | MLOps | MLX 신경망 학습 (Apple Silicon GPU) | -| `scripts/tune_hyperparams.py` | MLOps | Optuna 하이퍼파라미터 탐색 (수동 트리거) | -| `scripts/train_and_deploy.sh` | MLOps | 전체 파이프라인 (수집→학습→배포) | -| `scripts/deploy_model.sh` | MLOps | 모델 파일 LXC 서버 전송 | -| `models/active_lgbm_params.json` | MLOps | 승인된 LightGBM 파라미터 (Active Config) | +| `scripts/tune_hyperparams.py` | MLOps | Optuna 하이퍼파라미터 탐색 (`--symbol` 지원) | +| `scripts/train_and_deploy.sh` | MLOps | 전체 파이프라인 (`--symbol` / `--all` 지원) | +| `scripts/deploy_model.sh` | MLOps | 모델 파일 LXC 서버 전송 (`--symbol` 지원) | +| `models/{symbol}/active_lgbm_params.json` | MLOps | 심볼별 승인된 LightGBM 파라미터 (Active Config) | diff --git a/CLAUDE.md b/CLAUDE.md index 59e53c9..c8608d1 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -4,7 +4,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co ## Project Overview -CoinTrader is a Python asyncio-based automated cryptocurrency trading bot for Binance Futures. It trades XRPUSDT on 15-minute candles, using BTC/ETH as correlation features. The system has 5 layers: Data (WebSocket streams) → Signal (technical indicators) → ML Filter (ONNX/LightGBM) → Execution & Risk → Event/Alert (Discord). +CoinTrader is a Python asyncio-based automated cryptocurrency trading bot for Binance Futures. It supports multi-symbol simultaneous trading (XRP, TRX, DOGE etc.) on 15-minute candles, using BTC/ETH as correlation features. The system has 5 layers: Data (WebSocket streams) → Signal (technical indicators) → ML Filter (ONNX/LightGBM) → Execution & Risk → Event/Alert (Discord). ## Common Commands @@ -24,34 +24,44 @@ bash scripts/run_tests.sh -k "bot" # Run pytest directly pytest tests/ -v --tb=short -# ML training pipeline (LightGBM default) +# ML training pipeline (all symbols) bash scripts/train_and_deploy.sh +# Single symbol training +bash scripts/train_and_deploy.sh --symbol TRXUSDT + # MLX GPU training (macOS Apple Silicon) -bash scripts/train_and_deploy.sh mlx +bash scripts/train_and_deploy.sh mlx --symbol XRPUSDT # Hyperparameter tuning (50 trials, 5-fold walk-forward) -python scripts/tune_hyperparams.py +python scripts/tune_hyperparams.py --symbol XRPUSDT -# Fetch historical data +# Fetch historical data (single symbol with auto correlation) +python scripts/fetch_history.py --symbol TRXUSDT --interval 15m --days 365 + +# Fetch historical data (explicit symbols) python scripts/fetch_history.py --symbols XRPUSDT BTCUSDT ETHUSDT --interval 15m --days 365 # Deploy models to production -bash scripts/deploy_model.sh +bash scripts/deploy_model.sh --symbol XRPUSDT ``` ## Architecture -**Entry point**: `main.py` → creates `Config` (dataclass from env vars) → runs `TradingBot` +**Entry point**: `main.py` → creates `Config` → shared `RiskManager` → per-symbol `TradingBot` instances → `asyncio.gather()` + +**Multi-symbol architecture**: Each symbol gets its own `TradingBot` instance with independent `Exchange`, `MLFilter`, and `DataStream`. The `RiskManager` is shared as a singleton across all bots, enforcing global daily loss limits and same-direction position limits via `asyncio.Lock`. **5-layer data flow on each 15m candle close:** -1. `src/data_stream.py` — Combined WebSocket for XRP/BTC/ETH, deque buffers (200 candles each) +1. `src/data_stream.py` — Combined WebSocket for primary+correlation symbols, deque buffers (200 candles each) 2. `src/indicators.py` — RSI, MACD, BB, EMA, StochRSI, ATR; weighted signal aggregation → LONG/SHORT/HOLD 3. `src/ml_filter.py` + `src/ml_features.py` — 26-feature extraction (ADX + OI 파생 피처 포함), ONNX priority > LightGBM fallback, threshold ≥ 0.55 -4. `src/exchange.py` + `src/risk_manager.py` — Dynamic margin, MARKET orders with SL/TP, daily loss limit (5%) +4. `src/exchange.py` + `src/risk_manager.py` — Dynamic margin, MARKET orders with SL/TP, daily loss limit (5%), same-direction limit 5. `src/user_data_stream.py` + `src/notifier.py` — Real-time TP/SL detection via WebSocket, Discord webhooks -**Parallel execution**: `user_data_stream` runs independently via `asyncio.gather()` alongside candle processing. +**Parallel execution**: Per-symbol bots run independently via `asyncio.gather()`. Each bot's `user_data_stream` also runs in parallel. + +**Model/data directories**: `models/{symbol}/` and `data/{symbol}/` for per-symbol models. Falls back to `models/` root if symbol dir doesn't exist. ## Key Patterns @@ -72,7 +82,7 @@ bash scripts/deploy_model.sh ## Configuration -Environment variables via `.env` file (see `.env.example`). Key vars: `BINANCE_API_KEY`, `BINANCE_API_SECRET`, `SYMBOL` (default XRPUSDT), `LEVERAGE`, `DISCORD_WEBHOOK_URL`, `MARGIN_MAX_RATIO`, `MARGIN_MIN_RATIO`, `NO_ML_FILTER`. +Environment variables via `.env` file (see `.env.example`). Key vars: `BINANCE_API_KEY`, `BINANCE_API_SECRET`, `SYMBOLS` (comma-separated, e.g. `XRPUSDT,TRXUSDT`), `CORRELATION_SYMBOLS` (default `BTCUSDT,ETHUSDT`), `LEVERAGE`, `DISCORD_WEBHOOK_URL`, `MARGIN_MAX_RATIO`, `MARGIN_MIN_RATIO`, `MAX_SAME_DIRECTION` (default 2), `NO_ML_FILTER`. `src/config.py` uses `@dataclass` with `__post_init__` to load and validate all env vars. @@ -80,7 +90,7 @@ Environment variables via `.env` file (see `.env.example`). Key vars: `BINANCE_A - **Docker**: `Dockerfile` (Python 3.12-slim) + `docker-compose.yml` - **CI/CD**: Jenkins pipeline (Gitea → Docker registry → LXC production server) -- Models stored in `models/`, data cache in `data/`, logs in `logs/` +- Models stored in `models/{symbol}/`, data cache in `data/{symbol}/`, logs in `logs/` ## Design & Implementation Plans @@ -118,3 +128,4 @@ All design documents and implementation plans are stored in `docs/plans/` with t | 2026-03-03 | `optuna-precision-objective-plan` | Completed | | 2026-03-03 | `demo-1m-125x` (design + plan) | In Progress | | 2026-03-04 | `oi-derived-features` (design + plan) | Completed | +| 2026-03-05 | `multi-symbol-trading` (design + plan) | Completed | diff --git a/README.md b/README.md index eea34b4..afea9e3 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # CoinTrader -Binance Futures 자동매매 봇. 복합 기술 지표와 ML 필터(LightGBM / MLX 신경망)를 결합하여 XRPUSDT(기본) 선물 포지션을 자동으로 진입·청산하며, Discord로 실시간 알림을 전송합니다. +Binance Futures 자동매매 봇. 복합 기술 지표와 ML 필터(LightGBM / MLX 신경망)를 결합하여 다중 심볼(XRP, TRX, DOGE 등) 선물 포지션을 동시에 자동 진입·청산하며, Discord로 실시간 알림을 전송합니다. > **아키텍처 문서**: 코드 구조, 레이어별 역할, MLOps 파이프라인, 동작 시나리오를 상세히 설명한 [ARCHITECTURE.md](./ARCHITECTURE.md)를 참고하세요. @@ -19,7 +19,8 @@ Binance Futures 자동매매 봇. 복합 기술 지표와 ML 필터(LightGBM / M - **Algo Order API 지원**: 계정 설정에 따라 STOP_MARKET/TAKE_PROFIT_MARKET 주문을 `/fapi/v1/algoOrder` 엔드포인트로 자동 전송 (오류 코드 -4120 대응) - **동적 증거금 비율**: 잔고 증가에 따라 선형 감소 (최대 50% → 최소 20%) - **반대 시그널 재진입**: 보유 포지션과 반대 신호 발생 시 즉시 청산 후 ML 필터 통과 시 반대 방향 재진입 -- **리스크 관리**: 트레이드당 리스크 비율, 최대 포지션 수, 일일 손실 한도(5%) 제어 +- **멀티심볼 동시 거래**: 심볼별 독립 봇 인스턴스를 `asyncio.gather()`로 병렬 실행. 공유 RiskManager로 글로벌 리스크 관리 +- **리스크 관리**: 트레이드당 리스크 비율, 최대 포지션 수, 동일 방향 포지션 제한(기본 2개), 일일 손실 한도(5%) 제어 - **포지션 복구**: 봇 재시작 시 기존 포지션 자동 감지 및 상태 복원 - **실시간 TP/SL 감지**: Binance User Data Stream으로 TP/SL 작동을 즉시 감지 (캔들 마감 대기 없음) - **순수익(Net PnL) 기록**: 바이낸스 `realizedProfit - commission`으로 정확한 순수익 계산 @@ -34,34 +35,40 @@ Binance Futures 자동매매 봇. 복합 기술 지표와 ML 필터(LightGBM / M ``` cointrader/ -├── main.py # 진입점 +├── main.py # 진입점 (심볼별 봇 인스턴스 생성 + asyncio.gather) ├── src/ -│ ├── bot.py # 메인 트레이딩 루프 -│ ├── config.py # 환경변수 기반 설정 -│ ├── exchange.py # Binance Futures API 클라이언트 -│ ├── data_stream.py # WebSocket 15분봉 멀티심볼 스트림 (XRP/BTC/ETH) +│ ├── bot.py # 메인 트레이딩 루프 (심볼별 독립 인스턴스) +│ ├── config.py # 환경변수 기반 설정 (symbols 리스트 지원) +│ ├── exchange.py # Binance Futures API 클라이언트 (심볼별 독립) +│ ├── data_stream.py # WebSocket 15분봉 멀티심볼 스트림 │ ├── indicators.py # 기술 지표 계산 및 신호 생성 │ ├── ml_filter.py # ML 필터 (ONNX 우선 / LightGBM 폴백 / 핫리로드) -│ ├── ml_features.py # ML 피처 빌더 (23개 피처) +│ ├── ml_features.py # ML 피처 빌더 (26개 피처) │ ├── mlx_filter.py # MLX 신경망 필터 (Apple Silicon GPU 학습 + ONNX export) │ ├── label_builder.py # 학습 레이블 생성 │ ├── dataset_builder.py # 벡터화 데이터셋 빌더 (학습용) -│ ├── risk_manager.py # 리스크 관리 (일일 손실 한도, 동적 증거금 비율) +│ ├── risk_manager.py # 공유 리스크 관리 (asyncio.Lock, 동일 방향 제한) │ ├── notifier.py # Discord 웹훅 알림 │ └── logger_setup.py # Loguru 로거 설정 ├── scripts/ -│ ├── fetch_history.py # 과거 데이터 수집 (XRP/BTC/ETH + OI/펀딩비, Upsert 지원) -│ ├── train_model.py # LightGBM 모델 학습 (CPU) +│ ├── fetch_history.py # 과거 데이터 수집 (--symbol 단일 / --symbols 다중) +│ ├── train_model.py # LightGBM 모델 학습 (--symbol 지원) │ ├── train_mlx_model.py # MLX 신경망 학습 (Apple Silicon GPU) -│ ├── train_and_deploy.sh # 전체 파이프라인 (수집 → 학습 → LXC 배포) -│ ├── tune_hyperparams.py # Optuna 하이퍼파라미터 자동 탐색 (수동 트리거) -│ ├── deploy_model.sh # 모델 파일 LXC 서버 전송 +│ ├── train_and_deploy.sh # 전체 파이프라인 (--symbol / --all 지원) +│ ├── tune_hyperparams.py # Optuna 하이퍼파라미터 자동 탐색 (--symbol 지원) +│ ├── deploy_model.sh # 모델 파일 LXC 서버 전송 (--symbol 지원) │ └── run_tests.sh # 전체 테스트 실행 ├── dashboard/ │ ├── api/ # FastAPI 백엔드 (로그 파서 + REST API) │ └── ui/ # React 프론트엔드 (Vite + Recharts) -├── models/ # 학습된 모델 저장 (.pkl / .onnx) -├── data/ # 과거 데이터 캐시 (.parquet) +├── models/ # 학습된 모델 저장 (심볼별 하위 디렉토리) +│ ├── xrpusdt/ # models/xrpusdt/lgbm_filter.pkl +│ ├── trxusdt/ # models/trxusdt/lgbm_filter.pkl +│ └── dogeusdt/ # models/dogeusdt/lgbm_filter.pkl +├── data/ # 과거 데이터 캐시 (심볼별 하위 디렉토리) +│ ├── xrpusdt/ # data/xrpusdt/combined_15m.parquet +│ ├── trxusdt/ # data/trxusdt/combined_15m.parquet +│ └── dogeusdt/ # data/dogeusdt/combined_15m.parquet ├── logs/ # 로그 파일 ├── docs/plans/ # 설계 문서 및 구현 플랜 ├── tests/ # 테스트 코드 @@ -86,8 +93,10 @@ cp .env.example .env ```env BINANCE_API_KEY=your_api_key BINANCE_API_SECRET=your_api_secret -SYMBOL=XRPUSDT +SYMBOLS=XRPUSDT,TRXUSDT,DOGEUSDT +CORRELATION_SYMBOLS=BTCUSDT,ETHUSDT LEVERAGE=10 +MAX_SAME_DIRECTION=2 DISCORD_WEBHOOK_URL=https://discord.com/api/webhooks/... ``` @@ -120,14 +129,17 @@ docker compose logs -f cointrader 맥미니에서 데이터 수집 → 학습 → LXC 배포까지 한 번에 실행합니다. -> **자동 분기**: `data/combined_15m.parquet`가 없으면 1년치(365일) 전체 수집, 있으면 35일치 Upsert로 자동 전환합니다. 서버 이전이나 데이터 유실 시에도 사람의 개입 없이 자동 복구됩니다. +> **자동 분기**: `data/{symbol}/combined_15m.parquet`가 없으면 1년치(365일) 전체 수집, 있으면 35일치 Upsert로 자동 전환합니다. 서버 이전이나 데이터 유실 시에도 사람의 개입 없이 자동 복구됩니다. ```bash -# LightGBM + Walk-Forward 5폴드 (기본값) +# 전체 심볼 학습 + 배포 (SYMBOLS 환경변수의 모든 심볼) bash scripts/train_and_deploy.sh -# MLX GPU 학습 + Walk-Forward 5폴드 -bash scripts/train_and_deploy.sh mlx +# 단일 심볼만 학습 + 배포 +bash scripts/train_and_deploy.sh --symbol TRXUSDT + +# MLX GPU 학습 (단일 심볼) +bash scripts/train_and_deploy.sh mlx --symbol XRPUSDT # LightGBM + Walk-Forward 3폴드 bash scripts/train_and_deploy.sh lgbm 3 @@ -139,34 +151,30 @@ bash scripts/train_and_deploy.sh lgbm 0 ### 단계별 수동 실행 ```bash -# 1. 과거 데이터 수집 (XRP/BTC/ETH 3심볼, 15분봉, 1년치 + OI/펀딩비) -# 기본값: Upsert 활성화 — 기존 parquet의 oi_change/funding_rate=0 구간을 실제 값으로 채움 +# 1. 과거 데이터 수집 (단일 심볼 — 상관관계 심볼 자동 추가) +python scripts/fetch_history.py --symbol TRXUSDT --interval 15m --days 365 +# → data/trxusdt/combined_15m.parquet 에 저장 + +# 1-alt. 명시적 심볼 지정 (기존 방식도 지원) python scripts/fetch_history.py \ --symbols XRPUSDT BTCUSDT ETHUSDT \ --interval 15m \ --days 365 \ --output data/combined_15m.parquet -# 기존 파일을 완전히 덮어쓰려면 --no-upsert 플래그 사용 -python scripts/fetch_history.py \ - --symbols XRPUSDT BTCUSDT ETHUSDT \ - --interval 15m \ - --days 365 \ - --output data/combined_15m.parquet \ - --no-upsert - -# 2-A. LightGBM 모델 학습 (CPU) -python scripts/train_model.py --data data/combined_15m.parquet +# 2-A. LightGBM 모델 학습 (심볼별) +python scripts/train_model.py --symbol TRXUSDT +# → models/trxusdt/lgbm_filter.pkl 에 저장 # 2-B. MLX 신경망 학습 (Apple Silicon GPU) -python scripts/train_mlx_model.py --data data/combined_15m.parquet +python scripts/train_mlx_model.py --data data/xrpusdt/combined_15m.parquet # 3. LXC 서버에 모델 배포 -bash scripts/deploy_model.sh # LightGBM -bash scripts/deploy_model.sh mlx # MLX (ONNX) +bash scripts/deploy_model.sh --symbol XRPUSDT +bash scripts/deploy_model.sh mlx --symbol XRPUSDT ``` -학습된 모델은 `models/lgbm_filter.pkl` (LightGBM) 또는 `models/mlx_filter.weights.onnx` (MLX) 에 저장됩니다. +학습된 모델은 `models/{symbol}/lgbm_filter.pkl` (LightGBM) 또는 `models/{symbol}/mlx_filter.weights.onnx` (MLX) 에 저장됩니다. 심볼별 디렉토리가 없으면 `models/` 루트로 폴백합니다. > **모델 핫리로드**: 봇이 실행 중일 때 모델 파일을 교체하면, 다음 캔들 마감 시 자동으로 감지해 리로드합니다. 봇 재시작이 필요 없습니다. @@ -176,17 +184,17 @@ bash scripts/deploy_model.sh mlx # MLX (ONNX) 결과를 확인하고 직접 승인한 후 재학습에 반영하는 **수동 트리거** 방식입니다. ```bash -# 기본 실행 (50 trials, 5폴드 Walk-Forward, ~30분) -python scripts/tune_hyperparams.py +# 심볼별 튜닝 (50 trials, 5폴드 Walk-Forward, ~30분) +python scripts/tune_hyperparams.py --symbol XRPUSDT # 빠른 테스트 (10 trials, 3폴드, ~5분) -python scripts/tune_hyperparams.py --trials 10 --folds 3 +python scripts/tune_hyperparams.py --symbol TRXUSDT --trials 10 --folds 3 # 베이스라인 측정 없이 탐색만 -python scripts/tune_hyperparams.py --no-baseline +python scripts/tune_hyperparams.py --symbol XRPUSDT --no-baseline ``` -결과는 `models/tune_results_YYYYMMDD_HHMMSS.json`에 저장됩니다. +결과는 `models/{symbol}/tune_results_YYYYMMDD_HHMMSS.json`에 저장됩니다. 콘솔에 Best Params, 베이스라인 대비 개선폭, 폴드별 AUC를 출력하므로 직접 확인 후 판단하세요. > **주의**: Optuna가 찾은 파라미터는 과적합 위험이 있습니다. Best Params를 `train_model.py`에 반영하기 전에 반드시 폴드별 AUC 분산과 개선폭을 검토하세요. @@ -305,8 +313,10 @@ pytest tests/ -v |------|--------|------| | `BINANCE_API_KEY` | — | Binance API 키 | | `BINANCE_API_SECRET` | — | Binance API 시크릿 | -| `SYMBOL` | `XRPUSDT` | 거래 심볼 | +| `SYMBOLS` | `XRPUSDT` | 거래 심볼 목록 (쉼표 구분, 예: `XRPUSDT,TRXUSDT,DOGEUSDT`) | +| `CORRELATION_SYMBOLS` | `BTCUSDT,ETHUSDT` | 상관관계 심볼 (BTC/ETH 수익률·상대강도 피처용) | | `LEVERAGE` | `10` | 레버리지 배수 | +| `MAX_SAME_DIRECTION` | `2` | 동일 방향 최대 포지션 수 (LONG 2개면 3번째 LONG 차단) | | `DISCORD_WEBHOOK_URL` | — | Discord 웹훅 URL | | `MARGIN_MAX_RATIO` | `0.50` | 최대 증거금 비율 (잔고 대비 50%) | | `MARGIN_MIN_RATIO` | `0.20` | 최소 증거금 비율 (잔고 대비 20%) | diff --git a/data/dogeusdt/.gitkeep b/data/dogeusdt/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/data/trxusdt/.gitkeep b/data/trxusdt/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/data/xrpusdt/.gitkeep b/data/xrpusdt/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/docs/plans/2026-03-05-multi-symbol-trading-design.md b/docs/plans/2026-03-05-multi-symbol-trading-design.md new file mode 100644 index 0000000..e121198 --- /dev/null +++ b/docs/plans/2026-03-05-multi-symbol-trading-design.md @@ -0,0 +1,209 @@ +# Multi-Symbol Trading Design + +## 개요 + +현재 XRP 단일 심볼 선물 거래 봇을 TRX, DOGE 등 다중 심볼 동시 거래로 확장한다. + +## 요구사항 + +- **거래 심볼**: XRPUSDT, TRXUSDT, DOGEUSDT (3개, 추후 확장 가능) +- **상관관계 심볼**: BTCUSDT, ETHUSDT (기존과 동일) +- **ML 모델**: 심볼별 개별 학습·배포 +- **포지션**: 심볼별 동시 포지션 허용 (최대 3개) +- **리스크**: 심볼별 독립 운영 + 글로벌 한도 (일일 손실 5%) +- **동일 방향 제한**: 같은 방향(LONG/SHORT) 최대 2개까지 (BTC 급락 시 3배 손실 방지) + +## 접근법: 심볼별 독립 TradingBot 인스턴스 + 공유 RiskManager + +기존 TradingBot의 단일 포지션 상태 머신을 유지하면서, 각 심볼마다 독립 인스턴스를 생성하고 `asyncio.gather()`로 병렬 실행한다. RiskManager만 싱글턴으로 공유하여 글로벌 리스크를 관리한다. + +### 선택 이유 + +- 기존 TradingBot 상태 머신 수정 최소화 +- 심볼 간 완전 격리 — 한 심볼의 에러가 다른 심볼에 영향 없음 +- 점진적 확장 용이 (새 심볼 = 새 인스턴스 추가) +- 각 단계마다 기존 XRP 단일 모드로 테스트 가능 + +### 기각된 대안: 단일 Bot + 심볼 라우팅 + +하나의 TradingBot에서 `Dict[str, PositionState]`로 관리하는 방식. WebSocket 효율적이나 상태 머신 대규모 리팩토링 필요, 한 심볼 에러가 전체에 영향, 복잡도 대폭 증가. + +## 설계 상세 + +### 1. Config 변경 + +```python +# .env +SYMBOLS=XRPUSDT,TRXUSDT,DOGEUSDT +CORRELATION_SYMBOLS=BTCUSDT,ETHUSDT +MAX_SAME_DIRECTION=2 + +@dataclass +class Config: + symbols: list[str] # ["XRPUSDT", "TRXUSDT", "DOGEUSDT"] + correlation_symbols: list[str] # ["BTCUSDT", "ETHUSDT"] + max_same_direction: int # 같은 방향 최대 수 (기본 2) + # symbol: str 필드 제거 +``` + +- 기존 `SYMBOL` 환경변수 제거, `SYMBOLS`로 통일 +- `config.symbol` 참조하는 코드 모두 → 각 봇 인스턴스의 `self.symbol`로 전환 +- 하위호환: `SYMBOLS` 미설정 시 기존 `SYMBOL` 값을 1개짜리 리스트로 변환 + +### 2. 실행 구조 (main.py) + +```python +async def main(): + config = Config() + risk = RiskManager(config) # 공유 싱글턴 + + bots = [] + for symbol in config.symbols: + bot = TradingBot(config, symbol=symbol, risk=risk) + bots.append(bot) + + await asyncio.gather(*[bot.run() for bot in bots]) +``` + +- 각 봇은 독립적인 MultiSymbolStream, Exchange, UserDataStream 보유 +- RiskManager만 공유 + +### 3. TradingBot 생성자 변경 + +```python +class TradingBot: + def __init__(self, config: Config, symbol: str, risk: RiskManager): + self.symbol = symbol + self.config = config + self.exchange = BinanceFuturesClient(config, symbol=symbol) + self.risk = risk # 외부에서 주입 (공유) + self.ml_filter = MLFilter(model_dir=f"models/{symbol.lower()}") + ... +``` + +- `config.symbol` 의존 완전 제거 +- 각 봇이 자기 심볼을 직접 소유 + +### 4. Exchange 심볼 분리 + +```python +class BinanceFuturesClient: + def __init__(self, config: Config, symbol: str): + self.symbol = symbol # config.symbol → self.symbol +``` + +- 모든 API 호출에서 `self.config.symbol` → `self.symbol` + +### 5. RiskManager 공유 설계 + +```python +class RiskManager: + def __init__(self, config): + self.daily_pnl = 0.0 + self.open_positions: dict[str, str] = {} # {symbol: side} + self.max_positions = config.max_positions + self.max_same_direction = config.max_same_direction # 기본 2 + self._lock = asyncio.Lock() + + async def can_open_new_position(self, symbol: str, side: str) -> bool: + async with self._lock: + if len(self.open_positions) >= self.max_positions: + return False + if symbol in self.open_positions: + return False + same_dir = sum(1 for s in self.open_positions.values() if s == side) + if same_dir >= self.max_same_direction: + return False + return True + + async def register_position(self, symbol: str, side: str): + async with self._lock: + self.open_positions[symbol] = side + + async def close_position(self, symbol: str, pnl: float): + async with self._lock: + self.open_positions.pop(symbol, None) + self.daily_pnl += pnl + + def is_trading_allowed(self) -> bool: + # 글로벌 일일 손실 한도 체크 (기존과 동일) +``` + +- `asyncio.Lock()`으로 동시 접근 보호 +- 동일 방향 2개 제한으로 BTC 급락 시 3배 손실 방지 +- 마진은 심볼 수(N)로 균등 배분 + +### 6. 데이터 스트림 + +각 TradingBot이 자기만의 MultiSymbolStream 인스턴스를 가짐: + +``` +XRP Bot: [XRPUSDT, BTCUSDT, ETHUSDT] +TRX Bot: [TRXUSDT, BTCUSDT, ETHUSDT] +DOGE Bot: [DOGEUSDT, BTCUSDT, ETHUSDT] +``` + +- BTC/ETH 데이터 중복 수신되지만 격리성 확보 +- 각 stream의 primary_symbol이 달라 candle close 콜백 독립적 + +### 7. 모델 & 데이터 디렉토리 분리 + +``` +models/ +├── xrpusdt/ +│ ├── lgbm_filter.pkl +│ └── mlx_filter.weights.onnx +├── trxusdt/ +│ └── ... +└── dogeusdt/ + └── ... + +data/ +├── xrpusdt/ +│ └── combined_15m.parquet +├── trxusdt/ +│ └── combined_15m.parquet +└── dogeusdt/ + └── combined_15m.parquet +``` + +- 각 parquet: 해당 심볼이 primary + BTC/ETH가 correlation +- feature 구조 동일 (26 features) + +### 8. 학습 파이프라인 CLI 통일 + +모든 스크립트에 `--symbol`과 `--all` 패턴 적용: + +```bash +# 단일 심볼 +bash scripts/train_and_deploy.sh --symbol TRXUSDT +python scripts/fetch_history.py --symbol DOGEUSDT +python scripts/train_model.py --symbol TRXUSDT +python scripts/tune_hyperparams.py --symbol DOGEUSDT + +# 전체 심볼 +bash scripts/train_and_deploy.sh --all +bash scripts/train_and_deploy.sh # 인자 없으면 --all 동일 + +# MLX + 단일 심볼 +bash scripts/train_and_deploy.sh mlx --symbol DOGEUSDT +``` + +## 구현 순서 + +각 단계마다 기존 XRP 단일 모드로 테스트 가능하도록 점진적 전환: + +1. **Config** — `symbols` 리스트, `max_same_direction` 추가 +2. **RiskManager** — 공유 싱글턴, asyncio.Lock, 동일 방향 제한 +3. **exchange.py** — `config.symbol` → `self.symbol` 분리 +4. **bot.py** — 생성자에 `symbol`, `risk` 파라미터 추가, `config.symbol` 제거 +5. **main.py** — 심볼별 봇 인스턴스 생성 + `asyncio.gather()` +6. **학습 스크립트** — `--symbol`/`--all` CLI, 디렉토리 분리 + +## 변경 불필요한 컴포넌트 + +- `src/indicators.py` — 이미 심볼에 독립적 +- `src/notifier.py` — 이미 symbol 파라미터 수용 +- `src/user_data_stream.py` — 이미 심볼별 필터링 지원 +- `src/ml_features.py` — 이미 primary + auxiliary 구조 +- `src/label_builder.py` — 이미 범용적 diff --git a/docs/plans/2026-03-05-multi-symbol-trading-plan.md b/docs/plans/2026-03-05-multi-symbol-trading-plan.md new file mode 100644 index 0000000..1dcb706 --- /dev/null +++ b/docs/plans/2026-03-05-multi-symbol-trading-plan.md @@ -0,0 +1,920 @@ +# Multi-Symbol Trading Implementation Plan + +> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task. + +**Goal:** XRP 단일 심볼 거래 봇을 TRX·DOGE 등 다중 심볼 동시 거래로 확장한다. + +**Architecture:** 심볼별 독립 TradingBot 인스턴스를 `asyncio.gather()`로 병렬 실행. RiskManager만 공유 싱글턴으로 글로벌 리스크(일일 손실 한도, 동일 방향 제한)를 관리한다. 각 봇은 자기 심볼을 직접 소유하고, `config.symbol` 의존을 완전 제거한다. + +**Tech Stack:** Python asyncio, LightGBM, ONNX, Binance Futures API + +**Design Doc:** `docs/plans/2026-03-05-multi-symbol-trading-design.md` + +--- + +## Task 1: Config — `symbols` 리스트 추가, `symbol` 필드 유지(하위호환) + +**Files:** +- Modify: `src/config.py` +- Modify: `tests/test_config.py` +- Modify: `.env.example` + +**Step 1: Write the failing tests** + +`tests/test_config.py`에 다음 테스트를 추가: + +```python +def test_config_loads_symbols_list(): + """SYMBOLS 환경변수로 쉼표 구분 리스트를 로드한다.""" + os.environ["SYMBOLS"] = "XRPUSDT,TRXUSDT,DOGEUSDT" + os.environ.pop("SYMBOL", None) + cfg = Config() + assert cfg.symbols == ["XRPUSDT", "TRXUSDT", "DOGEUSDT"] + + +def test_config_fallback_to_symbol(): + """SYMBOLS 미설정 시 SYMBOL에서 1개짜리 리스트로 변환한다.""" + os.environ.pop("SYMBOLS", None) + os.environ["SYMBOL"] = "XRPUSDT" + cfg = Config() + assert cfg.symbols == ["XRPUSDT"] + + +def test_config_correlation_symbols(): + """상관관계 심볼 로드.""" + os.environ["CORRELATION_SYMBOLS"] = "BTCUSDT,ETHUSDT" + cfg = Config() + assert cfg.correlation_symbols == ["BTCUSDT", "ETHUSDT"] + + +def test_config_max_same_direction_default(): + """동일 방향 최대 수 기본값 2.""" + cfg = Config() + assert cfg.max_same_direction == 2 +``` + +**Step 2: Run tests to verify they fail** + +Run: `pytest tests/test_config.py -v` +Expected: FAIL — `Config` has no `symbols`, `correlation_symbols`, `max_same_direction` attributes + +**Step 3: Implement Config changes** + +`src/config.py`를 수정: + +```python +@dataclass +class Config: + api_key: str = "" + api_secret: str = "" + symbol: str = "XRPUSDT" + symbols: list = None # NEW + correlation_symbols: list = None # NEW + leverage: int = 10 + max_positions: int = 3 + max_same_direction: int = 2 # NEW + stop_loss_pct: float = 0.015 + take_profit_pct: float = 0.045 + trailing_stop_pct: float = 0.01 + discord_webhook_url: str = "" + margin_max_ratio: float = 0.50 + margin_min_ratio: float = 0.20 + margin_decay_rate: float = 0.0006 + ml_threshold: float = 0.55 + + def __post_init__(self): + self.api_key = os.getenv("BINANCE_API_KEY", "") + self.api_secret = os.getenv("BINANCE_API_SECRET", "") + self.symbol = os.getenv("SYMBOL", "XRPUSDT") + self.leverage = int(os.getenv("LEVERAGE", "10")) + self.discord_webhook_url = os.getenv("DISCORD_WEBHOOK_URL", "") + self.margin_max_ratio = float(os.getenv("MARGIN_MAX_RATIO", "0.50")) + self.margin_min_ratio = float(os.getenv("MARGIN_MIN_RATIO", "0.20")) + self.margin_decay_rate = float(os.getenv("MARGIN_DECAY_RATE", "0.0006")) + self.ml_threshold = float(os.getenv("ML_THRESHOLD", "0.55")) + self.max_same_direction = int(os.getenv("MAX_SAME_DIRECTION", "2")) + + # symbols: SYMBOLS 환경변수 우선, 없으면 SYMBOL에서 변환 + symbols_env = os.getenv("SYMBOLS", "") + if symbols_env: + self.symbols = [s.strip() for s in symbols_env.split(",") if s.strip()] + else: + self.symbols = [self.symbol] + + # correlation_symbols + corr_env = os.getenv("CORRELATION_SYMBOLS", "BTCUSDT,ETHUSDT") + self.correlation_symbols = [s.strip() for s in corr_env.split(",") if s.strip()] +``` + +`.env.example`에 추가: + +``` +SYMBOLS=XRPUSDT +CORRELATION_SYMBOLS=BTCUSDT,ETHUSDT +MAX_SAME_DIRECTION=2 +``` + +**Step 4: Run tests to verify they pass** + +Run: `pytest tests/test_config.py -v` +Expected: ALL PASS + +**Step 5: Run full test suite to verify no regressions** + +Run: `bash scripts/run_tests.sh` +Expected: ALL PASS (기존 코드는 `config.symbol`을 여전히 사용 가능하므로 깨지지 않음) + +**Step 6: Commit** + +```bash +git add src/config.py tests/test_config.py .env.example +git commit -m "feat: add multi-symbol config (symbols list, correlation_symbols, max_same_direction)" +``` + +--- + +## Task 2: RiskManager — 공유 싱글턴, asyncio.Lock, 동일 방향 제한 + +**Files:** +- Modify: `src/risk_manager.py` +- Modify: `tests/test_risk_manager.py` + +**Step 1: Write the failing tests** + +`tests/test_risk_manager.py`에 추가: + +```python +import asyncio + + +@pytest.fixture +def shared_risk(config): + config.max_same_direction = 2 + return RiskManager(config) + + +@pytest.mark.asyncio +async def test_can_open_new_position_async(shared_risk): + """비동기 포지션 오픈 허용 체크.""" + assert await shared_risk.can_open_new_position("XRPUSDT", "LONG") is True + + +@pytest.mark.asyncio +async def test_register_and_close_position(shared_risk): + """포지션 등록 후 닫기.""" + await shared_risk.register_position("XRPUSDT", "LONG") + assert "XRPUSDT" in shared_risk.open_positions + await shared_risk.close_position("XRPUSDT", pnl=1.5) + assert "XRPUSDT" not in shared_risk.open_positions + assert shared_risk.daily_pnl == 1.5 + + +@pytest.mark.asyncio +async def test_same_symbol_blocked(shared_risk): + """같은 심볼 중복 진입 차단.""" + await shared_risk.register_position("XRPUSDT", "LONG") + assert await shared_risk.can_open_new_position("XRPUSDT", "SHORT") is False + + +@pytest.mark.asyncio +async def test_max_same_direction_limit(shared_risk): + """같은 방향 2개 초과 차단.""" + await shared_risk.register_position("XRPUSDT", "LONG") + await shared_risk.register_position("TRXUSDT", "LONG") + # 3번째 LONG 차단 + assert await shared_risk.can_open_new_position("DOGEUSDT", "LONG") is False + # SHORT은 허용 + assert await shared_risk.can_open_new_position("DOGEUSDT", "SHORT") is True + + +@pytest.mark.asyncio +async def test_max_positions_global_limit(shared_risk): + """전체 포지션 수 한도 초과 차단.""" + shared_risk.config.max_positions = 2 + await shared_risk.register_position("XRPUSDT", "LONG") + await shared_risk.register_position("TRXUSDT", "SHORT") + assert await shared_risk.can_open_new_position("DOGEUSDT", "LONG") is False +``` + +**Step 2: Run tests to verify they fail** + +Run: `pytest tests/test_risk_manager.py -v -k "async or register or same_direction"` +Expected: FAIL — `can_open_new_position`이 sync이고 파라미터가 없음 + +**Step 3: Implement RiskManager changes** + +`src/risk_manager.py` 전체 교체: + +```python +import asyncio +from loguru import logger +from src.config import Config + + +class RiskManager: + def __init__(self, config: Config, max_daily_loss_pct: float = 0.05): + self.config = config + self.max_daily_loss_pct = max_daily_loss_pct + self.daily_pnl: float = 0.0 + self.initial_balance: float = 0.0 + self.open_positions: dict[str, str] = {} # {symbol: side} + self._lock = asyncio.Lock() + + def is_trading_allowed(self) -> bool: + """일일 최대 손실 초과 시 거래 중단""" + if self.initial_balance <= 0: + return True + loss_pct = abs(self.daily_pnl) / self.initial_balance + if self.daily_pnl < 0 and loss_pct >= self.max_daily_loss_pct: + logger.warning( + f"일일 손실 한도 초과: {loss_pct:.2%} >= {self.max_daily_loss_pct:.2%}" + ) + return False + return True + + async def can_open_new_position(self, symbol: str, side: str) -> bool: + """포지션 오픈 가능 여부 (전체 한도 + 중복 진입 + 동일 방향 제한)""" + async with self._lock: + if len(self.open_positions) >= self.config.max_positions: + logger.info(f"최대 포지션 수 도달: {len(self.open_positions)}/{self.config.max_positions}") + return False + if symbol in self.open_positions: + logger.info(f"{symbol} 이미 포지션 보유 중") + return False + same_dir = sum(1 for s in self.open_positions.values() if s == side) + if same_dir >= self.config.max_same_direction: + logger.info(f"동일 방향({side}) 한도 도달: {same_dir}/{self.config.max_same_direction}") + return False + return True + + async def register_position(self, symbol: str, side: str): + """포지션 등록""" + async with self._lock: + self.open_positions[symbol] = side + logger.info(f"포지션 등록: {symbol} {side} (현재 {len(self.open_positions)}개)") + + async def close_position(self, symbol: str, pnl: float): + """포지션 닫기 + PnL 기록""" + async with self._lock: + self.open_positions.pop(symbol, None) + self.daily_pnl += pnl + logger.info(f"포지션 종료: {symbol}, PnL={pnl:+.4f}, 누적={self.daily_pnl:+.4f}") + + def record_pnl(self, pnl: float): + self.daily_pnl += pnl + logger.info(f"오늘 누적 PnL: {self.daily_pnl:.4f} USDT") + + def reset_daily(self): + """매일 자정 초기화""" + self.daily_pnl = 0.0 + logger.info("일일 PnL 초기화") + + def set_base_balance(self, balance: float) -> None: + """봇 시작 시 기준 잔고 설정""" + self.initial_balance = balance + + def get_dynamic_margin_ratio(self, balance: float) -> float: + """잔고에 따라 선형 감소하는 증거금 비율 반환""" + ratio = self.config.margin_max_ratio - ( + (balance - self.initial_balance) * self.config.margin_decay_rate + ) + return max(self.config.margin_min_ratio, min(self.config.margin_max_ratio, ratio)) +``` + +주요 변경: +- `open_positions: list` → `dict[str, str]` (심볼→방향 매핑) +- `can_open_new_position()` → `async` + `symbol`, `side` 파라미터 +- `register_position()`, `close_position()` 새 메서드 추가 +- `asyncio.Lock()` 동시성 보호 + +**Step 4: Fix existing tests that break** + +기존 테스트에서 `can_open_new_position()` 호출 방식이 바뀌었으므로 수정: + +`tests/test_risk_manager.py`의 `test_position_size_capped`를 수정: + +```python +@pytest.mark.asyncio +async def test_position_size_capped(config): + rm = RiskManager(config, max_daily_loss_pct=0.05) + await rm.register_position("XRPUSDT", "LONG") + await rm.register_position("TRXUSDT", "SHORT") + await rm.register_position("DOGEUSDT", "LONG") + assert await rm.can_open_new_position("SOLUSDT", "SHORT") is False +``` + +**Step 5: Run tests to verify they pass** + +Run: `pytest tests/test_risk_manager.py -v` +Expected: ALL PASS + +**Step 6: Run full test suite** + +Run: `bash scripts/run_tests.sh` +Expected: `test_bot.py`에서 `can_open_new_position()` 호출이 깨질 수 있음 — Task 4에서 수정할 것이므로 지금은 bot 테스트 실패 허용 + +**Step 7: Commit** + +```bash +git add src/risk_manager.py tests/test_risk_manager.py +git commit -m "feat: shared RiskManager with async lock, same-direction limit, per-symbol tracking" +``` + +--- + +## Task 3: Exchange — `config.symbol` → `self.symbol` 분리 + +**Files:** +- Modify: `src/exchange.py` +- Modify: `tests/test_exchange.py` + +**Step 1: Write the failing test** + +`tests/test_exchange.py`에 추가: + +```python +def test_exchange_uses_own_symbol(): + """Exchange 클라이언트가 config.symbol 대신 생성자의 symbol을 사용한다.""" + os.environ.update({ + "BINANCE_API_KEY": "test_key", + "BINANCE_API_SECRET": "test_secret", + "SYMBOL": "XRPUSDT", + }) + config = Config() + with patch("src.exchange.Client"): + client = BinanceFuturesClient(config, symbol="TRXUSDT") + assert client.symbol == "TRXUSDT" +``` + +**Step 2: Run test to verify it fails** + +Run: `pytest tests/test_exchange.py::test_exchange_uses_own_symbol -v` +Expected: FAIL — `__init__` doesn't accept `symbol` parameter + +**Step 3: Implement Exchange changes** + +`src/exchange.py` 생성자 변경: + +```python +class BinanceFuturesClient: + def __init__(self, config: Config, symbol: str = None): + self.config = config + self.symbol = symbol or config.symbol + self.client = Client( + api_key=config.api_key, + api_secret=config.api_secret, + ) +``` + +모든 `self.config.symbol` 참조를 `self.symbol`로 교체 (9곳): +- Line 34: `set_leverage` → `symbol=self.symbol` +- Line 71: `place_order` params → `symbol=self.symbol` +- Line 101: `_place_algo_order` params → `symbol=self.symbol` +- Line 123: `get_position` → `symbol=self.symbol` +- Line 137: `cancel_all_orders` 일반 → `symbol=self.symbol` +- Line 144: `cancel_all_orders` algo → `symbol=self.symbol` +- Line 156: `get_open_interest` → `symbol=self.symbol` +- Line 169: `get_funding_rate` → `symbol=self.symbol` +- Line 183: `get_oi_history` → `symbol=self.symbol` + +**Step 4: Fix existing test fixtures** + +기존 `exchange` 픽스처에서 `BinanceFuturesClient.__new__`를 사용하는 곳에 `c.symbol` 설정 추가: + +```python +@pytest.fixture +def client(): + config = Config() + config.leverage = 10 + c = BinanceFuturesClient.__new__(BinanceFuturesClient) + c.config = config + c.symbol = config.symbol # NEW + return c + + +@pytest.fixture +def exchange(): + os.environ.update({ + "BINANCE_API_KEY": "test_key", + "BINANCE_API_SECRET": "test_secret", + "SYMBOL": "XRPUSDT", + "LEVERAGE": "10", + }) + config = Config() + c = BinanceFuturesClient.__new__(BinanceFuturesClient) + c.config = config + c.symbol = config.symbol # NEW + c.client = MagicMock() + return c +``` + +**Step 5: Run tests to verify they pass** + +Run: `pytest tests/test_exchange.py -v` +Expected: ALL PASS + +**Step 6: Commit** + +```bash +git add src/exchange.py tests/test_exchange.py +git commit -m "feat: exchange client accepts explicit symbol parameter, removes config.symbol dependency" +``` + +--- + +## Task 4: TradingBot — 생성자에 `symbol`, `risk` 주입 + +**Files:** +- Modify: `src/bot.py` +- Modify: `tests/test_bot.py` + +**Step 1: Write the failing tests** + +`tests/test_bot.py`에 추가: + +```python +def test_bot_accepts_symbol_and_risk(config): + """TradingBot이 symbol과 risk를 외부에서 주입받을 수 있다.""" + from src.risk_manager import RiskManager + risk = RiskManager(config) + with patch("src.bot.BinanceFuturesClient"): + bot = TradingBot(config, symbol="TRXUSDT", risk=risk) + assert bot.symbol == "TRXUSDT" + assert bot.risk is risk + + +def test_bot_stream_uses_injected_symbol(config): + """봇의 stream이 주입된 심볼을 primary로 사용한다.""" + from src.risk_manager import RiskManager + risk = RiskManager(config) + with patch("src.bot.BinanceFuturesClient"): + bot = TradingBot(config, symbol="DOGEUSDT", risk=risk) + assert "dogeusdt" in bot.stream.buffers + + +def test_bot_ml_filter_uses_symbol_model_dir(config): + """봇의 MLFilter가 심볼별 모델 디렉토리를 사용한다.""" + from src.risk_manager import RiskManager + risk = RiskManager(config) + with patch("src.bot.BinanceFuturesClient"): + bot = TradingBot(config, symbol="TRXUSDT", risk=risk) + assert "trxusdt" in str(bot.ml_filter._onnx_path) + assert "trxusdt" in str(bot.ml_filter._lgbm_path) +``` + +**Step 2: Run tests to verify they fail** + +Run: `pytest tests/test_bot.py -v -k "accepts_symbol or injected_symbol or symbol_model_dir"` +Expected: FAIL — `TradingBot.__init__` doesn't accept `symbol` or `risk` + +**Step 3: Implement TradingBot changes** + +`src/bot.py`의 `__init__` 변경: + +```python +class TradingBot: + def __init__(self, config: Config, symbol: str = None, risk: RiskManager = None): + self.config = config + self.symbol = symbol or config.symbol + self.exchange = BinanceFuturesClient(config, symbol=self.symbol) + self.notifier = DiscordNotifier(config.discord_webhook_url) + self.risk = risk or RiskManager(config) + self.ml_filter = MLFilter( + onnx_path=f"models/{self.symbol.lower()}/mlx_filter.weights.onnx", + lgbm_path=f"models/{self.symbol.lower()}/lgbm_filter.pkl", + threshold=config.ml_threshold, + ) + self.current_trade_side: str | None = None + self._entry_price: float | None = None + self._entry_quantity: float | None = None + self._is_reentering: bool = False + self._prev_oi: float | None = None + self._oi_history: deque = deque(maxlen=5) + self._latest_ret_1: float = 0.0 + self.stream = MultiSymbolStream( + symbols=[self.symbol] + config.correlation_symbols, + interval="15m", + on_candle=self._on_candle_closed, + ) +``` + +`_on_candle_closed` 변경: + +```python + async def _on_candle_closed(self, candle: dict): + primary_df = self.stream.get_dataframe(self.symbol) + btc_df = self.stream.get_dataframe("BTCUSDT") + eth_df = self.stream.get_dataframe("ETHUSDT") + if primary_df is not None: + await self.process_candle(primary_df, btc_df=btc_df, eth_df=eth_df) +``` + +`process_candle`에서 `can_open_new_position` 호출 변경 (2곳): + +```python +# Line ~138 (신규 진입): +if not await self.risk.can_open_new_position(self.symbol, raw_signal): + logger.info(f"[{self.symbol}] 포지션 오픈 불가") + return + +# Line ~322 (_close_and_reenter 내): +if not await self.risk.can_open_new_position(self.symbol, signal): + logger.info(f"[{self.symbol}] 최대 포지션 수 도달 — 재진입 건너뜀") + return +``` + +`_open_position`에서 `register_position` 호출 추가: + +```python + async def _open_position(self, signal: str, df): + balance = await self.exchange.get_balance() + # 심볼 수로 마진 균등 배분 + num_symbols = len(self.config.symbols) + per_symbol_balance = balance / num_symbols + price = df["close"].iloc[-1] + margin_ratio = self.risk.get_dynamic_margin_ratio(balance) + quantity = self.exchange.calculate_quantity( + balance=per_symbol_balance, price=price, + leverage=self.config.leverage, margin_ratio=margin_ratio, + ) + # ... 기존 로직 ... + + # 포지션 등록 + await self.risk.register_position(self.symbol, signal) + self.current_trade_side = signal + # ... 나머지 동일 ... +``` + +`_on_position_closed`에서 `close_position` 호출: + +```python + async def _on_position_closed(self, net_pnl, close_reason, exit_price): + # ... 기존 PnL 계산 로직 ... + await self.risk.close_position(self.symbol, net_pnl) + # record_pnl 제거 (close_position 내에서 처리) + # ... 나머지 동일 ... +``` + +모든 `self.config.symbol` 참조를 `self.symbol`로 교체 (6곳): +- Line 31 → `self.symbol` (stream symbols) +- Line 37 → `self.symbol` (get_dataframe) +- Line 197 → `self.symbol` (notify_open) +- Line 251 → `self.symbol` (notify_close) +- Line 340 → `self.symbol` (run 로그) +- Line 348 → `self.symbol` (UserDataStream) + +`run()` 메서드의 로그도 변경: + +```python + async def run(self): + logger.info(f"[{self.symbol}] 봇 시작, 레버리지 {self.config.leverage}x") + # ... 나머지 동일, self.config.symbol → self.symbol ... +``` + +**Step 4: Fix existing bot tests** + +기존 `tests/test_bot.py`의 모든 `TradingBot(config)` 호출은 하위호환되므로 그대로 동작. +단, `risk.can_open_new_position` 호출이 async로 바뀌었으므로 mock 수정 필요: + +`test_close_and_reenter_calls_open_when_ml_passes`: +```python + bot.risk = MagicMock() + bot.risk.can_open_new_position = AsyncMock(return_value=True) +``` + +`test_close_and_reenter_skips_open_when_max_positions_reached`: +```python + bot.risk = MagicMock() + bot.risk.can_open_new_position = AsyncMock(return_value=False) +``` + +`test_bot_processes_signal`에서 `bot.risk`도 mock: +```python + bot.risk = MagicMock() + bot.risk.is_trading_allowed.return_value = True + bot.risk.can_open_new_position = AsyncMock(return_value=True) + bot.risk.register_position = AsyncMock() + bot.risk.get_dynamic_margin_ratio.return_value = 0.50 +``` + +**Step 5: Run tests to verify they pass** + +Run: `pytest tests/test_bot.py -v` +Expected: ALL PASS + +**Step 6: Run full test suite** + +Run: `bash scripts/run_tests.sh` +Expected: ALL PASS + +**Step 7: Commit** + +```bash +git add src/bot.py tests/test_bot.py +git commit -m "feat: TradingBot accepts symbol and shared RiskManager, removes config.symbol dependency" +``` + +--- + +## Task 5: main.py — 심볼별 봇 인스턴스 생성 + asyncio.gather + +**Files:** +- Modify: `main.py` + +**Step 1: Implement main.py changes** + +```python +import asyncio +from dotenv import load_dotenv +from src.config import Config +from src.bot import TradingBot +from src.risk_manager import RiskManager +from src.logger_setup import setup_logger +from loguru import logger + +load_dotenv() + + +async def main(): + setup_logger(log_level="INFO") + config = Config() + risk = RiskManager(config) + + bots = [] + for symbol in config.symbols: + bot = TradingBot(config, symbol=symbol, risk=risk) + bots.append(bot) + + logger.info(f"멀티심볼 봇 시작: {config.symbols} ({len(bots)}개 인스턴스)") + await asyncio.gather(*[bot.run() for bot in bots]) + + +if __name__ == "__main__": + asyncio.run(main()) +``` + +**Step 2: Run full test suite to verify no regressions** + +Run: `bash scripts/run_tests.sh` +Expected: ALL PASS + +**Step 3: Commit** + +```bash +git add main.py +git commit -m "feat: main.py spawns per-symbol TradingBot instances with shared RiskManager" +``` + +--- + +## Task 6: MLFilter — 심볼별 모델 디렉토리 폴백 + +**Files:** +- Modify: `src/ml_filter.py` + +**Step 1: Implement MLFilter path fallback** + +MLFilter는 이미 `onnx_path`/`lgbm_path`를 생성자에서 받으므로, bot.py에서 심볼별 경로를 주입하면 된다 (Task 4에서 완료). + +다만 기존 `models/lgbm_filter.pkl` 경로에 모델이 있는 경우(단일 심볼 환경)에도 동작하도록, 심볼별 디렉토리에 모델이 없으면 루트 `models/`에서 폴백하는 로직을 `bot.py`에 추가: + +`src/bot.py`의 `__init__`에서: + +```python + # 심볼별 모델 디렉토리. 없으면 기존 models/ 루트로 폴백 + symbol_model_dir = Path(f"models/{self.symbol.lower()}") + if symbol_model_dir.exists(): + onnx_path = str(symbol_model_dir / "mlx_filter.weights.onnx") + lgbm_path = str(symbol_model_dir / "lgbm_filter.pkl") + else: + onnx_path = "models/mlx_filter.weights.onnx" + lgbm_path = "models/lgbm_filter.pkl" + self.ml_filter = MLFilter( + onnx_path=onnx_path, + lgbm_path=lgbm_path, + threshold=config.ml_threshold, + ) +``` + +**Step 2: Run full test suite** + +Run: `bash scripts/run_tests.sh` +Expected: ALL PASS + +**Step 3: Commit** + +```bash +git add src/bot.py +git commit -m "feat: MLFilter falls back to models/ root if symbol-specific dir not found" +``` + +--- + +## Task 7: 학습 스크립트 — `--symbol` / `--all` CLI 통일 + +**Files:** +- Modify: `scripts/fetch_history.py` +- Modify: `scripts/train_model.py` +- Modify: `scripts/tune_hyperparams.py` +- Modify: `scripts/train_and_deploy.sh` +- Modify: `scripts/deploy_model.sh` + +### Step 1: fetch_history.py — `--symbol` 단일 심볼 + 출력 경로 자동 결정 + +`scripts/fetch_history.py`의 argparse에 `--symbol` 추가 및 `--output` 자동 결정: + +현재 사용법: `--symbols XRPUSDT BTCUSDT ETHUSDT --output data/combined_15m.parquet` + +변경 후: +```python +parser.add_argument("--symbol", type=str, default=None, + help="단일 거래 심볼 (예: TRXUSDT). 상관관계 심볼 자동 추가") +``` + +`--symbol TRXUSDT` 지정 시: +- `symbols = ["TRXUSDT", "BTCUSDT", "ETHUSDT"]` +- `output = "data/trxusdt/combined_15m.parquet"` (자동) + +`--symbols XRPUSDT BTCUSDT ETHUSDT` (기존 방식)도 유지. + +### Step 2: train_model.py — `--symbol` 추가 + +```python +parser.add_argument("--symbol", type=str, default=None, + help="학습 대상 심볼 (예: TRXUSDT). data/{symbol}/ 에서 데이터 로드, models/{symbol}/ 에 저장") +``` + +`--symbol TRXUSDT` 지정 시: +- 데이터: `data/trxusdt/combined_15m.parquet` +- 모델: `models/trxusdt/lgbm_filter.pkl` +- 로그: `models/trxusdt/training_log.json` + +`--data` 옵션이 명시되면 그것을 우선. + +### Step 3: tune_hyperparams.py — `--symbol` 추가 + +train_model.py와 동일한 패턴. `--symbol`이 지정되면: +- 데이터: `data/{symbol}/combined_15m.parquet` +- 결과: `models/{symbol}/tune_results_*.json` +- active params: `models/{symbol}/active_lgbm_params.json` + +### Step 4: train_and_deploy.sh — `--symbol` / `--all` 지원 + +```bash +# 사용법: +# bash scripts/train_and_deploy.sh [mlx|lgbm] [--symbol TRXUSDT] +# bash scripts/train_and_deploy.sh [mlx|lgbm] --all +# bash scripts/train_and_deploy.sh # --all과 동일 (기본값) +``` + +`--symbol` 지정 시: 해당 심볼만 fetch → train → deploy +`--all` 또는 인자 없음: `SYMBOLS` 환경변수의 모든 심볼 순차 처리 + +핵심 로직: +```bash +if [ -n "$SYMBOL_ARG" ]; then + TARGETS=("$SYMBOL_ARG") +else + # .env에서 SYMBOLS 로드 + TARGETS=($(python -c "from src.config import Config; c=Config(); print(' '.join(c.symbols))")) +fi + +for SYM in "${TARGETS[@]}"; do + SYM_LOWER=$(echo "$SYM" | tr '[:upper:]' '[:lower:]') + mkdir -p "data/$SYM_LOWER" "models/$SYM_LOWER" + + # fetch + python scripts/fetch_history.py --symbol "$SYM" ... + + # train + python scripts/train_model.py --symbol "$SYM" ... + + # deploy + bash scripts/deploy_model.sh "$BACKEND" --symbol "$SYM" +done +``` + +### Step 5: deploy_model.sh — `--symbol` 지원 + +```bash +# 사용법: bash scripts/deploy_model.sh [lgbm|mlx] [--symbol TRXUSDT] +``` + +`--symbol` 지정 시: +- 로컬: `models/{symbol}/lgbm_filter.pkl` +- 원격: `$LXC_MODELS_PATH/{symbol}/lgbm_filter.pkl` + +### Step 6: Run full test suite + +Run: `bash scripts/run_tests.sh` +Expected: ALL PASS (스크립트 변경은 unit test에 영향 없음) + +### Step 7: Smoke test 스크립트 + +```bash +# fetch만 소량 테스트 +python scripts/fetch_history.py --symbol TRXUSDT --interval 15m --days 1 +ls data/trxusdt/combined_15m.parquet # 파일 존재 확인 +``` + +### Step 8: Commit + +```bash +git add scripts/fetch_history.py scripts/train_model.py scripts/tune_hyperparams.py scripts/train_and_deploy.sh scripts/deploy_model.sh +git commit -m "feat: add --symbol/--all CLI to all training scripts for per-symbol pipeline" +``` + +--- + +## Task 8: 디렉토리 구조 생성 + .env.example 업데이트 + +**Files:** +- Create: `models/xrpusdt/.gitkeep` +- Create: `models/trxusdt/.gitkeep` +- Create: `models/dogeusdt/.gitkeep` +- Create: `data/xrpusdt/.gitkeep` +- Create: `data/trxusdt/.gitkeep` +- Create: `data/dogeusdt/.gitkeep` +- Modify: `.env.example` + +**Step 1: Create directory structure** + +```bash +mkdir -p models/{xrpusdt,trxusdt,dogeusdt} +mkdir -p data/{xrpusdt,trxusdt,dogeusdt} +touch models/{xrpusdt,trxusdt,dogeusdt}/.gitkeep +touch data/{xrpusdt,trxusdt,dogeusdt}/.gitkeep +``` + +**Step 2: Update .env.example** + +``` +BINANCE_API_KEY= +BINANCE_API_SECRET= +SYMBOLS=XRPUSDT +CORRELATION_SYMBOLS=BTCUSDT,ETHUSDT +LEVERAGE=10 +RISK_PER_TRADE=0.02 +DISCORD_WEBHOOK_URL= +ML_THRESHOLD=0.55 +MAX_SAME_DIRECTION=2 +BINANCE_TESTNET_API_KEY= +BINANCE_TESTNET_API_SECRET= +``` + +**Step 3: Commit** + +```bash +git add models/ data/ .env.example +git commit -m "feat: add per-symbol model/data directories and update .env.example" +``` + +--- + +## Task 9: 기존 모델 마이그레이션 안내 + 문서 업데이트 + +**Files:** +- Modify: `CLAUDE.md` + +**Step 1: Update CLAUDE.md** + +Architecture 섹션에 멀티심볼 관련 내용 추가: + +- `main.py` → `Config` → 심볼별 `TradingBot` 인스턴스 → `asyncio.gather()` +- `RiskManager` 공유 싱글턴 (글로벌 일일 손실 + 동일 방향 제한) +- 모델/데이터 디렉토리: `models/{symbol}/`, `data/{symbol}/` + +Common Commands 섹션 업데이트: + +```bash +# 단일 심볼 학습 +bash scripts/train_and_deploy.sh --symbol TRXUSDT + +# 전체 심볼 학습 +bash scripts/train_and_deploy.sh --all +``` + +**Step 2: Commit** + +```bash +git add CLAUDE.md +git commit -m "docs: update architecture and commands for multi-symbol trading" +``` + +--- + +## 구현 순서 요약 + +| Task | 내용 | 의존성 | +|------|------|--------| +| 1 | Config: `symbols`, `correlation_symbols`, `max_same_direction` | 없음 | +| 2 | RiskManager: 공유 싱글턴, async Lock, 동일 방향 제한 | Task 1 | +| 3 | Exchange: `self.symbol` 분리 | 없음 (Task 1과 병렬 가능) | +| 4 | TradingBot: `symbol`, `risk` 주입, `config.symbol` 제거 | Task 1, 2, 3 | +| 5 | main.py: 심볼별 봇 생성 + gather | Task 4 | +| 6 | MLFilter: 심볼별 모델 디렉토리 폴백 | Task 4 | +| 7 | 학습 스크립트: `--symbol` / `--all` CLI | Task 1 | +| 8 | 디렉토리 구조 + .env.example | 없음 | +| 9 | 문서 업데이트 | 전체 완료 후 | + +각 태스크 완료 후 기존 XRP 단일 모드에서 전체 테스트를 통과해야 한다. diff --git a/models/dogeusdt/.gitkeep b/models/dogeusdt/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/models/trxusdt/.gitkeep b/models/trxusdt/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/models/xrpusdt/.gitkeep b/models/xrpusdt/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/scripts/deploy_model.sh b/scripts/deploy_model.sh index 143d4f8..575e3a6 100755 --- a/scripts/deploy_model.sh +++ b/scripts/deploy_model.sh @@ -1,25 +1,57 @@ #!/usr/bin/env bash # 맥미니에서 학습한 모델을 LXC 컨테이너 볼륨 경로로 전송한다. -# 사용법: bash scripts/deploy_model.sh [lgbm|mlx] +# 사용법: bash scripts/deploy_model.sh [lgbm|mlx] [--symbol TRXUSDT] # # 예시: -# bash scripts/deploy_model.sh # LightGBM (기본값) -# bash scripts/deploy_model.sh mlx # MLX 신경망 +# bash scripts/deploy_model.sh # LightGBM (기본값), models/ 루트 +# bash scripts/deploy_model.sh mlx # MLX 신경망, models/ 루트 +# bash scripts/deploy_model.sh --symbol TRXUSDT # LightGBM, models/trxusdt/ +# bash scripts/deploy_model.sh mlx --symbol XRPUSDT # MLX, models/xrpusdt/ set -euo pipefail -BACKEND="${1:-lgbm}" +# ── 인자 파싱 ──────────────────────────────────────────────────────────────── +BACKEND="lgbm" +SYMBOL_ARG="" + +while [[ $# -gt 0 ]]; do + case "$1" in + --symbol) + SYMBOL_ARG="$2" + shift 2 + ;; + mlx|lgbm) + BACKEND="$1" + shift + ;; + *) + shift + ;; + esac +done + LXC_HOST="root@10.1.10.24" LXC_MODELS_PATH="/root/cointrader/models" -LOCAL_LOG="models/training_log.json" + +# ── 심볼별 경로 결정 ───────────────────────────────────────────────────────── +if [ -n "$SYMBOL_ARG" ]; then + SYM_LOWER=$(echo "$SYMBOL_ARG" | tr '[:upper:]' '[:lower:]') + LOCAL_MODEL_DIR="models/$SYM_LOWER" + REMOTE_MODEL_DIR="$LXC_MODELS_PATH/$SYM_LOWER" + LOCAL_LOG="models/$SYM_LOWER/training_log.json" +else + LOCAL_MODEL_DIR="models" + REMOTE_MODEL_DIR="$LXC_MODELS_PATH" + LOCAL_LOG="models/training_log.json" +fi # ── 백엔드별 파일 목록 설정 ────────────────────────────────────────────────── # mlx: ONNX 파일만 전송 (Linux 서버는 onnxruntime으로 추론) # lgbm: pkl 파일 전송 if [ "$BACKEND" = "mlx" ]; then - LOCAL_FILES=("models/mlx_filter.weights.onnx") + LOCAL_FILES=("$LOCAL_MODEL_DIR/mlx_filter.weights.onnx") else - LOCAL_FILES=("models/lgbm_filter.pkl") + LOCAL_FILES=("$LOCAL_MODEL_DIR/lgbm_filter.pkl") fi # ── 파일 존재 확인 ──────────────────────────────────────────────────────────── @@ -30,26 +62,26 @@ for f in "${LOCAL_FILES[@]}"; do fi done -echo "=== 모델 전송 시작 (백엔드: ${BACKEND}) ===" -echo " 대상: ${LXC_HOST}:${LXC_MODELS_PATH}" +echo "=== 모델 전송 시작 (백엔드: ${BACKEND}${SYMBOL_ARG:+, 심볼: $SYMBOL_ARG}) ===" +echo " 대상: ${LXC_HOST}:${REMOTE_MODEL_DIR}" # ── 원격 디렉터리 생성 + 백업 + 상대 백엔드 파일 제거 ─────────────────────── # lgbm 배포 시: 기존 lgbm 백업 후 ONNX 파일 삭제 (ONNX 우선순위 때문에 lgbm이 무시되는 것 방지) # mlx 배포 시: lgbm 파일 삭제 (명시적으로 mlx만 사용) ssh "${LXC_HOST}" " - mkdir -p '${LXC_MODELS_PATH}' + mkdir -p '${REMOTE_MODEL_DIR}' if [ '$BACKEND' = 'lgbm' ]; then - if [ -f '${LXC_MODELS_PATH}/lgbm_filter.pkl' ]; then - cp '${LXC_MODELS_PATH}/lgbm_filter.pkl' '${LXC_MODELS_PATH}/lgbm_filter_prev.pkl' + if [ -f '${REMOTE_MODEL_DIR}/lgbm_filter.pkl' ]; then + cp '${REMOTE_MODEL_DIR}/lgbm_filter.pkl' '${REMOTE_MODEL_DIR}/lgbm_filter_prev.pkl' echo ' 기존 lgbm 모델 백업 완료' fi - if [ -f '${LXC_MODELS_PATH}/mlx_filter.weights.onnx' ]; then - rm '${LXC_MODELS_PATH}/mlx_filter.weights.onnx' + if [ -f '${REMOTE_MODEL_DIR}/mlx_filter.weights.onnx' ]; then + rm '${REMOTE_MODEL_DIR}/mlx_filter.weights.onnx' echo ' ONNX 파일 제거 완료 (lgbm 우선 적용)' fi else - if [ -f '${LXC_MODELS_PATH}/lgbm_filter.pkl' ]; then - rm '${LXC_MODELS_PATH}/lgbm_filter.pkl' + if [ -f '${REMOTE_MODEL_DIR}/lgbm_filter.pkl' ]; then + rm '${REMOTE_MODEL_DIR}/lgbm_filter.pkl' echo ' lgbm 파일 제거 완료 (mlx 우선 적용)' fi fi @@ -68,12 +100,12 @@ _send() { # ── 모델 파일 전송 ──────────────────────────────────────────────────────────── for f in "${LOCAL_FILES[@]}"; do - _send "$f" "${LXC_MODELS_PATH}/$(basename "$f")" + _send "$f" "${REMOTE_MODEL_DIR}/$(basename "$f")" done # ── 학습 로그 전송 ──────────────────────────────────────────────────────────── if [[ -f "$LOCAL_LOG" ]]; then - _send "$LOCAL_LOG" "${LXC_MODELS_PATH}/training_log.json" + _send "$LOCAL_LOG" "${REMOTE_MODEL_DIR}/training_log.json" echo " 학습 로그 전송 완료" fi diff --git a/scripts/fetch_history.py b/scripts/fetch_history.py index ddbfa12..e35ca35 100644 --- a/scripts/fetch_history.py +++ b/scripts/fetch_history.py @@ -333,9 +333,22 @@ def main(): ) args = parser.parse_args() - # 하위 호환: --symbol 단독 사용 시 symbols로 통합 - if args.symbol and args.symbols == ["XRPUSDT"]: - args.symbols = [args.symbol] + # --symbol 모드: 단일 거래 심볼 + 상관관계 심볼 자동 추가, 출력 경로 자동 결정 + if args.symbol: + from src.config import Config + try: + cfg = Config() + corr_symbols = cfg.correlation_symbols + except Exception: + corr_symbols = ["BTCUSDT", "ETHUSDT"] + args.symbols = [args.symbol] + corr_symbols + if args.output == "data/combined_15m.parquet": + sym_lower = args.symbol.lower() + os.makedirs(f"data/{sym_lower}", exist_ok=True) + args.output = f"data/{sym_lower}/combined_15m.parquet" + # 하위 호환: 단일 심볼만 지정된 경우 + elif args.symbols == ["XRPUSDT"] and not args.symbol: + pass # 기본값 유지 if len(args.symbols) == 1: df = asyncio.run(fetch_klines(args.symbols[0], args.interval, args.days)) diff --git a/scripts/train_and_deploy.sh b/scripts/train_and_deploy.sh index e6a2fa3..d1ae75d 100755 --- a/scripts/train_and_deploy.sh +++ b/scripts/train_and_deploy.sh @@ -1,13 +1,14 @@ #!/usr/bin/env bash # 맥미니에서 전체 학습 파이프라인을 실행하고 LXC로 배포한다. -# 사용법: bash scripts/train_and_deploy.sh [mlx|lgbm] [wf-splits] +# 사용법: bash scripts/train_and_deploy.sh [mlx|lgbm] [--symbol TRXUSDT] [--all] [wf-splits] # # 예시: -# bash scripts/train_and_deploy.sh # LightGBM + Walk-Forward 5폴드 (기본값) -# bash scripts/train_and_deploy.sh mlx # MLX GPU 학습 + Walk-Forward 5폴드 -# bash scripts/train_and_deploy.sh lgbm 3 # LightGBM + Walk-Forward 3폴드 -# bash scripts/train_and_deploy.sh mlx 0 # MLX 학습만 (Walk-Forward 건너뜀) -# bash scripts/train_and_deploy.sh lgbm 0 # LightGBM 학습만 (Walk-Forward 건너뜀) +# bash scripts/train_and_deploy.sh # 전체 심볼 (SYMBOLS 환경변수) + LightGBM +# bash scripts/train_and_deploy.sh --symbol TRXUSDT # TRXUSDT만 학습+배포 +# bash scripts/train_and_deploy.sh mlx --symbol TRXUSDT # MLX + TRXUSDT만 +# bash scripts/train_and_deploy.sh --all # 전체 심볼 순차 처리 +# bash scripts/train_and_deploy.sh lgbm 3 # 전체 심볼 + Walk-Forward 3폴드 +# bash scripts/train_and_deploy.sh mlx 0 # 전체 심볼 + MLX 학습만 (WF 건너뜀) set -euo pipefail @@ -26,77 +27,132 @@ else echo "경고: 가상환경을 찾을 수 없습니다 ($VENV_PATH). 시스템 Python을 사용합니다." >&2 fi -BACKEND="${1:-lgbm}" -WF_SPLITS="${2:-5}" # 두 번째 인자: Walk-Forward 폴드 수 (0이면 건너뜀) - cd "$PROJECT_ROOT" -mkdir -p data +# ── 인자 파싱 ─────────────────────────────────────────────────────────────── +BACKEND="lgbm" +WF_SPLITS="5" +SYMBOL_ARG="" +ALL_FLAG=false -PARQUET_FILE="data/combined_15m.parquet" +while [[ $# -gt 0 ]]; do + case "$1" in + --symbol) + SYMBOL_ARG="$2" + shift 2 + ;; + --all) + ALL_FLAG=true + shift + ;; + mlx|lgbm) + BACKEND="$1" + shift + ;; + *) + # 숫자면 WF_SPLITS로 처리 + if [[ "$1" =~ ^[0-9]+$ ]]; then + WF_SPLITS="$1" + fi + shift + ;; + esac +done -echo "" -echo "========================================" -echo " 학습 파이프라인 시작: $(date '+%Y-%m-%d %H:%M:%S %Z')" -echo "========================================" -echo "" - -echo "=== [1/3] 데이터 수집 (XRP + BTC + ETH 3심볼 + OI/펀딩비) ===" -if [ ! -f "$PARQUET_FILE" ]; then - echo " [최초 실행] 기존 데이터 없음 → 1년치(365일) 전체 수집 (--no-upsert)" - FETCH_DAYS=365 - UPSERT_FLAG="--no-upsert" +# ── 대상 심볼 결정 ────────────────────────────────────────────────────────── +if [ -n "$SYMBOL_ARG" ]; then + TARGETS=("$SYMBOL_ARG") else - echo " [일반 실행] 기존 데이터 존재 → 35일치 Upsert (OI/펀딩비 0.0 구간 보충)" - FETCH_DAYS=35 - UPSERT_FLAG="" + # .env에서 SYMBOLS 로드 (없으면 XRPUSDT 기본값) + TARGETS=($(python -c "from dotenv import load_dotenv; load_dotenv(); from src.config import Config; c=Config(); print(' '.join(c.symbols))")) fi -python scripts/fetch_history.py \ - --symbols XRPUSDT BTCUSDT ETHUSDT \ - --interval 15m \ - --days "$FETCH_DAYS" \ - $UPSERT_FLAG \ - --output "$PARQUET_FILE" - DECAY="${TIME_WEIGHT_DECAY:-2.0}" echo "" -echo "=== [1.5/3] OI 파생 피처 A/B 비교 ===" -python scripts/train_model.py --compare --data "$PARQUET_FILE" --decay "$DECAY" || true - +echo "========================================" +echo " 학습 파이프라인 시작: $(date '+%Y-%m-%d %H:%M:%S %Z')" +echo " 대상 심볼: ${TARGETS[*]}" +echo " 백엔드: ${BACKEND}, WF 폴드: ${WF_SPLITS}" +echo "========================================" echo "" -echo "=== [2/3] 모델 학습 (26개 피처: XRP 13 + BTC/ETH 8 + OI/펀딩비 2 + OI파생 2 + ADX) ===" -if [ "$BACKEND" = "mlx" ]; then - echo " 백엔드: MLX (Apple Silicon GPU), decay=${DECAY}" - python scripts/train_mlx_model.py --data data/combined_15m.parquet --decay "$DECAY" -else - echo " 백엔드: LightGBM (CPU), decay=${DECAY}" - python scripts/train_model.py --data data/combined_15m.parquet --decay "$DECAY" -fi -# Walk-Forward 검증 (WF_SPLITS > 0 인 경우) -if [ "$WF_SPLITS" -gt 0 ] 2>/dev/null; then +# ── 심볼별 파이프라인 ─────────────────────────────────────────────────────── +for SYM in "${TARGETS[@]}"; do + SYM_LOWER=$(echo "$SYM" | tr '[:upper:]' '[:lower:]') + mkdir -p "data/$SYM_LOWER" "models/$SYM_LOWER" + + PARQUET_FILE="data/$SYM_LOWER/combined_15m.parquet" + echo "" - echo "=== [2.5/3] Walk-Forward 검증 (${WF_SPLITS}폴드) ===" - if [ "$BACKEND" = "mlx" ]; then - python scripts/train_mlx_model.py \ - --data data/combined_15m.parquet \ - --decay "$DECAY" \ - --wf \ - --wf-splits "$WF_SPLITS" - else - python scripts/train_model.py \ - --data data/combined_15m.parquet \ - --decay "$DECAY" \ - --wf \ - --wf-splits "$WF_SPLITS" - fi -fi + echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━" + echo " [$SYM] 파이프라인 시작" + echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━" -echo "" -echo "=== [3/3] LXC 배포 ===" -bash scripts/deploy_model.sh "$BACKEND" + # === [1/3] 데이터 수집 === + echo "" + echo "=== [$SYM] [1/3] 데이터 수집 (+ BTC/ETH 상관관계 + OI/펀딩비) ===" + if [ ! -f "$PARQUET_FILE" ]; then + echo " [최초 실행] 기존 데이터 없음 → 1년치(365일) 전체 수집 (--no-upsert)" + FETCH_DAYS=365 + UPSERT_FLAG="--no-upsert" + else + echo " [일반 실행] 기존 데이터 존재 → 35일치 Upsert (OI/펀딩비 0.0 구간 보충)" + FETCH_DAYS=35 + UPSERT_FLAG="" + fi + + python scripts/fetch_history.py \ + --symbol "$SYM" \ + --interval 15m \ + --days "$FETCH_DAYS" \ + $UPSERT_FLAG + + # === [1.5/3] OI 파생 피처 A/B 비교 === + echo "" + echo "=== [$SYM] [1.5/3] OI 파생 피처 A/B 비교 ===" + python scripts/train_model.py --compare --symbol "$SYM" --decay "$DECAY" || true + + # === [2/3] 모델 학습 === + echo "" + echo "=== [$SYM] [2/3] 모델 학습 ===" + if [ "$BACKEND" = "mlx" ]; then + echo " 백엔드: MLX (Apple Silicon GPU), decay=${DECAY}" + python scripts/train_mlx_model.py --data "$PARQUET_FILE" --decay "$DECAY" + else + echo " 백엔드: LightGBM (CPU), decay=${DECAY}" + python scripts/train_model.py --symbol "$SYM" --decay "$DECAY" + fi + + # Walk-Forward 검증 (WF_SPLITS > 0 인 경우) + if [ "$WF_SPLITS" -gt 0 ] 2>/dev/null; then + echo "" + echo "=== [$SYM] [2.5/3] Walk-Forward 검증 (${WF_SPLITS}폴드) ===" + if [ "$BACKEND" = "mlx" ]; then + python scripts/train_mlx_model.py \ + --data "$PARQUET_FILE" \ + --decay "$DECAY" \ + --wf \ + --wf-splits "$WF_SPLITS" + else + python scripts/train_model.py \ + --symbol "$SYM" \ + --decay "$DECAY" \ + --wf \ + --wf-splits "$WF_SPLITS" + fi + fi + + # === [3/3] 배포 === + echo "" + echo "=== [$SYM] [3/3] LXC 배포 ===" + bash scripts/deploy_model.sh "$BACKEND" --symbol "$SYM" + + echo "" + echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━" + echo " [$SYM] 파이프라인 완료" + echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━" +done echo "" echo "=== 전체 파이프라인 완료: $(date '+%Y-%m-%d %H:%M:%S %Z') ===" diff --git a/scripts/train_model.py b/scripts/train_model.py index dbed0a7..aabbfa4 100644 --- a/scripts/train_model.py +++ b/scripts/train_model.py @@ -531,7 +531,9 @@ def compare(data_path: str, time_weight_decay: float = 2.0, tuned_params_path: s def main(): parser = argparse.ArgumentParser() - parser.add_argument("--data", default="data/combined_15m.parquet") + parser.add_argument("--data", default=None) + parser.add_argument("--symbol", type=str, default=None, + help="학습 대상 심볼 (예: TRXUSDT). data/{symbol}/ 에서 데이터 로드, models/{symbol}/ 에 저장") parser.add_argument( "--decay", type=float, default=2.0, help="시간 가중치 감쇠 강도 (0=균등, 2.0=최신이 ~7.4배 높음)", @@ -546,6 +548,20 @@ def main(): help="OI 파생 피처 추가 전후 A/B 성능 비교") args = parser.parse_args() + # --symbol 모드: 심볼별 디렉토리 경로 자동 결정 + if args.symbol: + sym_lower = args.symbol.lower() + if args.data is None: + args.data = f"data/{sym_lower}/combined_15m.parquet" + global MODEL_PATH, PREV_MODEL_PATH, LOG_PATH, ACTIVE_PARAMS_PATH + MODEL_PATH = Path(f"models/{sym_lower}/lgbm_filter.pkl") + PREV_MODEL_PATH = Path(f"models/{sym_lower}/lgbm_filter_prev.pkl") + LOG_PATH = Path(f"models/{sym_lower}/training_log.json") + ACTIVE_PARAMS_PATH = Path(f"models/{sym_lower}/active_lgbm_params.json") + MODEL_PATH.parent.mkdir(parents=True, exist_ok=True) + elif args.data is None: + args.data = "data/combined_15m.parquet" + if args.compare: compare(args.data, time_weight_decay=args.decay, tuned_params_path=args.tuned_params) elif args.wf: diff --git a/scripts/tune_hyperparams.py b/scripts/tune_hyperparams.py index f77bf6a..119b0f0 100755 --- a/scripts/tune_hyperparams.py +++ b/scripts/tune_hyperparams.py @@ -308,9 +308,10 @@ def measure_baseline( n_splits: int, train_ratio: float, min_recall: float = 0.35, + active_params_path: "Path | None" = None, ) -> tuple[float, dict]: """현재 실전 파라미터(active 파일 또는 하드코딩 기본값)로 베이스라인을 측정한다.""" - active_path = Path("models/active_lgbm_params.json") + active_path = active_params_path or Path("models/active_lgbm_params.json") if active_path.exists(): with open(active_path, "r", encoding="utf-8") as f: @@ -518,7 +519,9 @@ def save_results( def main(): parser = argparse.ArgumentParser(description="Optuna LightGBM 하이퍼파라미터 튜닝") - parser.add_argument("--data", default="data/combined_15m.parquet", help="학습 데이터 경로") + parser.add_argument("--data", default=None, help="학습 데이터 경로") + parser.add_argument("--symbol", type=str, default=None, + help="튜닝 대상 심볼 (예: TRXUSDT). data/{symbol}/ 에서 데이터 로드, models/{symbol}/ 에 저장") parser.add_argument("--trials", type=int, default=50, help="Optuna trial 수 (기본: 50)") parser.add_argument("--folds", type=int, default=5, help="Walk-Forward 폴드 수 (기본: 5)") parser.add_argument("--train-ratio", type=float, default=0.6, help="학습 구간 비율 (기본: 0.6)") @@ -526,16 +529,31 @@ def main(): parser.add_argument("--no-baseline", action="store_true", help="베이스라인 측정 건너뜀") args = parser.parse_args() + # --symbol 모드: 심볼별 디렉토리 경로 자동 결정 + if args.symbol: + sym_lower = args.symbol.lower() + if args.data is None: + args.data = f"data/{sym_lower}/combined_15m.parquet" + elif args.data is None: + args.data = "data/combined_15m.parquet" + # 1. 데이터셋 로드 (1회) X, y, w, source = load_dataset(args.data) # 2. 베이스라인 측정 + if args.symbol: + sym_lower = args.symbol.lower() + _active_params_path = Path(f"models/{sym_lower}/active_lgbm_params.json") + else: + _active_params_path = None + if args.no_baseline: baseline_score, baseline_details = 0.0, {} print("베이스라인 측정 건너뜀 (--no-baseline)\n") else: baseline_score, baseline_details = measure_baseline( X, y, w, source, args.folds, args.train_ratio, args.min_recall, + active_params_path=_active_params_path, ) bl_prec = baseline_details.get("mean_precision", 0.0) bl_auc = baseline_details.get("mean_auc", 0.0) @@ -593,16 +611,28 @@ def main(): elapsed = time.time() - start_time # 4. 결과 저장 및 출력 + import shutil output_path = save_results( study, baseline_score, baseline_details, elapsed, args.data, args.min_recall, ) + # --symbol 모드: 결과 파일을 심볼별 디렉토리로 이동 + if args.symbol: + sym_lower = args.symbol.lower() + sym_model_dir = Path(f"models/{sym_lower}") + sym_model_dir.mkdir(parents=True, exist_ok=True) + dest = sym_model_dir / output_path.name + shutil.move(str(output_path), str(dest)) + output_path = dest print_report( study, baseline_score, baseline_details, elapsed, output_path, args.min_recall, ) # 5. 성능 개선 시 active 파일 자동 갱신 - import shutil - active_path = Path("models/active_lgbm_params.json") + if args.symbol: + sym_lower = args.symbol.lower() + active_path = Path(f"models/{sym_lower}/active_lgbm_params.json") + else: + active_path = Path("models/active_lgbm_params.json") if not args.no_baseline and study.best_value > baseline_score: shutil.copy(output_path, active_path) best_prec = study.best_trial.user_attrs.get("mean_precision", 0.0)