836 lines
41 KiB
Python
836 lines
41 KiB
Python
#!/usr/bin/env python3
|
||
"""
|
||
kis_trader/backtest/param_search.py — 스캘핑 백테스트 파라미터 자동 탐색 (Grid Search)
|
||
======================================================================================
|
||
실행:
|
||
cd /home/hoon/kis_bot
|
||
python3 kis_trader/backtest/param_search.py
|
||
# 또는 패키지 모듈로
|
||
python3 -m kis_trader.backtest.param_search --mode coarse --apply-ai
|
||
|
||
옵션:
|
||
--start 시작일 (기본: 오늘-7일)
|
||
--end 종료일 (기본: 오늘)
|
||
--mode 탐색 모드: coarse(기본) / fine / full / wide
|
||
wide = 급등·최소가격·방어ON/OFF 등 방어축을 넓게(조합 수 큼)
|
||
--top 상위 N개 출력 (기본: 5000)
|
||
--min_trades 최소 거래 건수 필터 (기본: 1)
|
||
--apply 결과 N위 조합을 DB에 자동 적용 (기본: False, 지정하면 N 생략 시 1)
|
||
--apply-ai Gemini 로 수익·승률 기준 조합 하나 선택해서 DB 자동 적용
|
||
|
||
설명:
|
||
웹 API를 거치지 않고 scalping_engine 을 직접 호출하여 속도를 극대화했습니다.
|
||
피뢰침 방지(high_chase_thr)·급등주 필터(max_daily_chg)·방어필터 ON/OFF 도 그리드에 포함됩니다.
|
||
|
||
위치 이관 (2026-04 기준):
|
||
backtest_scalping/param_search.py → kis_trader/backtest/param_search.py
|
||
- ROOT = kis_bot 프로젝트 루트 (__file__ 기준 3단계 위)
|
||
- 결과 저장: kis_trader/backtest/results/ (구 backtest_scalping/results 는 그대로 유지)
|
||
- scalping_engine / database.TradeDB 는 ROOT 에서 그대로 임포트
|
||
"""
|
||
|
||
import sys, os, json, time, argparse, signal
|
||
import heapq
|
||
from datetime import datetime, timedelta
|
||
from itertools import product
|
||
from concurrent.futures import ProcessPoolExecutor, as_completed
|
||
from typing import Optional, List, Dict, Any, Tuple
|
||
|
||
MIN_WIN_RATE_DEFAULT = 52.0
|
||
|
||
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# 멀티프로세싱 안전장치 — 부모(마스터)가 죽으면 워커도 자동으로 함께 종료
|
||
# ─────────────────────────────────────────────────────────────────────────────
|
||
# Linux 의 `PR_SET_PDEATHSIG` 를 이용해 "부모가 죽으면 이 시그널을 내게 보내라"
|
||
# 고 커널에 요청. Ctrl+C / SIGTERM / SIGKILL 어느 경로로 부모가 사라져도 워커가
|
||
# 고아(PPID=1) 로 남지 않는다.
|
||
def _worker_init() -> None:
|
||
"""ProcessPoolExecutor initializer — 워커 생성 직후 한 번 호출된다."""
|
||
try:
|
||
if sys.platform.startswith("linux"):
|
||
import ctypes
|
||
PR_SET_PDEATHSIG = 1
|
||
libc = ctypes.CDLL("libc.so.6", use_errno=True)
|
||
libc.prctl(PR_SET_PDEATHSIG, signal.SIGTERM, 0, 0, 0)
|
||
except Exception:
|
||
pass # 비 Linux 환경이거나 prctl 불가 시 무시 (치명적이지 않음)
|
||
# 워커 프로세스에서는 부모의 KeyboardInterrupt 에 간섭하지 않도록 SIGINT 무시.
|
||
# (부모가 시그널을 받아 shutdown 하는 동안 워커가 중간에 예외로 죽으면
|
||
# 결과 수집 로직이 혼잡해짐)
|
||
try:
|
||
signal.signal(signal.SIGINT, signal.SIG_IGN)
|
||
except Exception:
|
||
pass
|
||
|
||
# kis_bot 루트를 경로에 추가 (스크립트·패키지 실행 모두 대응)
|
||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||
ROOT = os.path.dirname(os.path.dirname(HERE))
|
||
if ROOT not in sys.path:
|
||
sys.path.insert(0, ROOT)
|
||
if HERE not in sys.path:
|
||
sys.path.insert(0, HERE)
|
||
|
||
import logging
|
||
logging.getLogger("TradeDB").setLevel(logging.WARNING) # 반복 초기화 로그 억제
|
||
|
||
from database import TradeDB
|
||
import scalping_engine as se
|
||
|
||
# ──────────────────────────────────────────────────────────────────────────────
|
||
# 스캘핑 기본값 = 엔진에서 DB 로드 (백테스트 API와 동일 단일 소스, 실매매와 동기화)
|
||
# ──────────────────────────────────────────────────────────────────────────────
|
||
|
||
def _fixed_defaults():
|
||
"""엔진 get_scalping_defaults_from_db() 사용. UI/파람서치용으로 %/비율 변환."""
|
||
_d = se.get_scalping_defaults_from_db()
|
||
return {
|
||
"rsi_period": _d["rsi_period"],
|
||
"rsi_overbought": _d.get("rsi_overbought", 75.0), # 과열 차단 (그리드 탐색 제외, 고정값)
|
||
"slot_money": _d["slot_money"],
|
||
"vol_mult": _d["vol_mult"],
|
||
"trail_trigger": _d["trail_trigger"] * 100, # % 단위
|
||
"trail_stop": _d["trail_stop"] * 100, # % 단위
|
||
"cooldown_min": _d["cooldown_min"],
|
||
"time_start_hm": _d["time_start_hm"],
|
||
"time_end_hm": _d["time_end_hm"],
|
||
"max_daily": _d["max_daily"],
|
||
"fee_rate": _d["fee_rate"] * 100, # % 단위
|
||
"sell_tax": _d["sell_tax"] * 100, # % 단위
|
||
# 방어로직
|
||
"high_chase_thr": _d["high_chase_thr"], # 비율 (0.96)
|
||
"max_daily_chg": _d["max_daily_chg"], # % 단위
|
||
"min_price": _d["min_price"],
|
||
"max_loss_krw": _d["max_loss_krw"],
|
||
"min_margin": _d["min_margin"] * 100, # % 단위
|
||
"use_defense_filters": _d.get("use_defense_filters", True),
|
||
}
|
||
|
||
# RSI_OVERSOLD별 JSON 저장 개수 (한 RSI에 치중되지 않도록 균등 분배)
|
||
PER_RSI_JSON = 20
|
||
|
||
# ──────────────────────────────────────────────────────────────────────────────
|
||
# 결과 디렉터리 (신규 위치 우선, 구 경로도 계속 조회 가능)
|
||
# ──────────────────────────────────────────────────────────────────────────────
|
||
|
||
def _results_dir_for_write() -> str:
|
||
"""새로 저장할 결과는 kis_trader/backtest/results/ 에 둔다."""
|
||
d = os.path.join(HERE, "results")
|
||
os.makedirs(d, exist_ok=True)
|
||
return d
|
||
|
||
|
||
def _results_dirs_for_read() -> List[str]:
|
||
"""읽기용 디렉터리: 신규 → 구 순서."""
|
||
return [
|
||
os.path.join(HERE, "results"),
|
||
os.path.join(ROOT, "backtest_scalping", "results"),
|
||
]
|
||
|
||
|
||
def _latest_json(prefix: str) -> Optional[str]:
|
||
"""읽기용 디렉터리에서 prefix 로 시작하는 가장 최근 JSON 경로 반환."""
|
||
best_path, best_mtime = None, -1.0
|
||
for d in _results_dirs_for_read():
|
||
if not os.path.isdir(d):
|
||
continue
|
||
for f in os.listdir(d):
|
||
if not (f.startswith(prefix) and f.endswith(".json")):
|
||
continue
|
||
p = os.path.join(d, f)
|
||
try:
|
||
m = os.path.getmtime(p)
|
||
except OSError:
|
||
continue
|
||
if m > best_mtime:
|
||
best_mtime = m
|
||
best_path = p
|
||
return best_path
|
||
|
||
# ──────────────────────────────────────────────────────────────────────────────
|
||
# 파라미터 그리드 (min_price 등은 DB 앵커 기반 — 고정 1값만 쓰지 않음)
|
||
# ──────────────────────────────────────────────────────────────────────────────
|
||
|
||
def _min_price_grid():
|
||
"""DB get_scalping_defaults 의 min_price 를 포함한 최소가격 스윕 (저·중·고가 후보)."""
|
||
mp = int(_fixed_defaults()["min_price"])
|
||
return sorted(set([500, 1000, max(500, mp), min(mp + 5000, 200000), 50000, 100000]))
|
||
|
||
|
||
def _scalp_grids():
|
||
"""탐색 모드별 그리드. 호출 시점 DB 기본값으로 min_price 티어가 잡힘."""
|
||
mp_list = _min_price_grid()
|
||
# fine: 조합 폭주 완화 — min_price 는 앵커·고가 두 티어 + 전 구간 5만원
|
||
fd_mp = int(_fixed_defaults()["min_price"])
|
||
min_price_fine = sorted(set([1000, fd_mp, 50000]))
|
||
return {
|
||
# 빠른 1차 — 트레일·손익·RSI 핵심 축 + 방어 ON/OFF.
|
||
# ⚠️ trail_trigger=0 포함 = "트레일 OFF" 경로. 이 경로에서는 tp_pct 가
|
||
# 실제 상한선으로 작동하므로 tp 값 탐색이 의미 있어진다.
|
||
# 조합 수: 6 × 3 × 4 × 3 × 3 × 2 × 2 × 1 × 1 × 2 × 1 × 1 = 5,184
|
||
"coarse": {
|
||
"rsi_oversold": [15, 18, 21, 24, 26, 28], # 저·중·고 RSI 대표
|
||
"sl_pct": [0.8, 1.2, 1.5], # 보수·중·공격
|
||
"tp_pct": [1.5, 2.5, 3.5, 5.0], # 트레일 OFF 시 상한선
|
||
"drop_rate": [1.0, 1.5, 2.0], # 얕은·중·깊은 눌림
|
||
"trail_trigger": [0, 0.5, 1.0], # 0 = 트레일 OFF (tp_pct 의미 있음)
|
||
"trail_stop": [0.3, 0.5], # 추적 폭 (trigger=0 이면 무의미하지만 무해)
|
||
"high_chase_thr": [0.96, 1.0], # 피뢰침 보수 / OFF
|
||
"max_daily_chg": [28.0], # 상승장 대응 (coarse 에서는 고정)
|
||
"min_price": [1000], # coarse 에서는 저가 고정
|
||
"use_defense_filters": [True, False], # 방어 ON / OFF
|
||
"max_loss_krw": [200000], # 중간값 고정 (wide 에서 세분화)
|
||
"min_drop_pct_for_loss_cut": [0.015], # 1.5% 고정 (wide 에서 세분화)
|
||
},
|
||
# 세밀 2차 (트레일·쿨다운 포함 + 최소가격·방어)
|
||
"fine": {
|
||
"rsi_oversold": [15, 17, 19, 21, 25],
|
||
"sl_pct": [0.8, 1.0, 1.2, 1.5],
|
||
"tp_pct": [1.5, 2.0, 2.5, 3.0, 3.5],
|
||
"drop_rate": [1.0, 1.5, 2.0],
|
||
"trail_trigger": [0, 0.5, 0.8],
|
||
"trail_stop": [0.3, 0.4, 0.5],
|
||
"cooldown_min": [5, 10],
|
||
"high_chase_thr": [0.96, 0.98],
|
||
"max_daily_chg": [15.0, 20.0, 25.0],
|
||
"min_price": min_price_fine,
|
||
"use_defense_filters": [True, False],
|
||
"max_loss_krw": [150000, 200000, 300000],
|
||
"min_drop_pct_for_loss_cut": [0.01, 0.015, 0.02],
|
||
},
|
||
# 전체 탐색 (매우 오래 걸림)
|
||
"full": {
|
||
"rsi_oversold": [15, 17, 20, 25],
|
||
"sl_pct": [0.8, 1.0, 1.2, 1.5, 2.0],
|
||
"tp_pct": [1.5, 2.0, 2.5, 3.0, 4.0],
|
||
"drop_rate": [0.8, 1.0, 1.5, 2.0, 2.5],
|
||
"trail_trigger": [0, 0.5, 0.8, 1.0],
|
||
"trail_stop": [0.3, 0.4, 0.5, 0.8],
|
||
"cooldown_min": [5, 10],
|
||
"high_chase_thr": [0.96, 0.98, 1.0],
|
||
"max_daily_chg": [15.0, 20.0, 30.0],
|
||
"min_price": mp_list,
|
||
"use_defense_filters": [True, False],
|
||
"max_loss_krw": [100000, 200000, 300000],
|
||
"min_drop_pct_for_loss_cut": [0.01, 0.015, 0.02, 0.025],
|
||
},
|
||
# 방어축 광범위 (RSI·슬립은 coarse 보다 약간 줄이고 급등·min_price·방어를 넓게)
|
||
"wide": {
|
||
"rsi_oversold": [15, 17, 19, 21, 23, 25, 28],
|
||
"sl_pct": [0.8, 1.0, 1.2, 1.5],
|
||
"tp_pct": [1.5, 2.0, 2.5, 3.0],
|
||
"drop_rate": [1.0, 1.5, 2.0, 2.5],
|
||
"high_chase_thr": [0.96, 0.98, 1.0],
|
||
"max_daily_chg": [8.0, 12.0, 16.0, 20.0, 25.0, 30.0, 40.0],
|
||
"min_price": mp_list,
|
||
"use_defense_filters": [True, False],
|
||
"max_loss_krw": [100000, 200000, 300000],
|
||
"min_drop_pct_for_loss_cut": [0.01, 0.015, 0.02],
|
||
},
|
||
}
|
||
|
||
def _get_scalp_field_map():
|
||
"""스캘핑 파라미터 → env_config 컬럼 매핑 (apply / db_snapshot 공용). 웹·봇과 동일 키 저장."""
|
||
return {
|
||
"rsi_oversold": ("SCALP_RSI_OVERSOLD", lambda v: str(int(v))),
|
||
"rsi_overbought": ("SCALP_RSI_OVERBOUGHT", lambda v: str(int(v))),
|
||
"sl_pct": ("SCALP_STOP_LOSS_PCT", lambda v: str(float(v) / 100)),
|
||
"tp_pct": ("SCALP_TAKE_PROFIT_PCT", lambda v: str(float(v) / 100)),
|
||
"drop_rate": ("SCALP_MIN_DROP_RATE", lambda v: str(float(v) / 100)),
|
||
"trail_trigger": ("SCALP_ATR_UP_MULT", lambda v: str(float(v))),
|
||
"trail_stop": ("SCALP_ATR_DOWN_MULT", lambda v: str(float(v))),
|
||
"cooldown_min": ("SCALP_COOLDOWN_SEC", lambda v: str(int(float(v)) * 60)),
|
||
# 스캘핑 전용 방어로직 (꼬리잡기와 값 분리)
|
||
"high_chase_thr": ("SCALP_HIGH_PRICE_CHASE_THRESHOLD", lambda v: str(float(v))),
|
||
"max_daily_chg": ("SCALP_MAX_DAILY_CHANGE_PCT", lambda v: str(float(v))),
|
||
"min_price": ("SCALP_MIN_PRICE", lambda v: str(int(float(v)))),
|
||
"max_loss_krw": ("SCALP_MAX_LOSS_PER_TRADE_KRW", lambda v: str(int(float(v)))),
|
||
"min_drop_pct_for_loss_cut": ("SCALP_MIN_DROP_PCT_FOR_LOSS_CUT", lambda v: str(round(float(v)*100, 2)) if float(v) < 1 else str(round(float(v), 2))), # % (1.5)
|
||
"min_margin": ("SCALP_MIN_PROFIT_PCT", lambda v: str(float(v))), # % 단위 (0.2 등)
|
||
"use_defense_filters": ("SCALP_USE_DEFENSE_FILTERS", lambda v: "true" if v else "false"),
|
||
}
|
||
|
||
|
||
def _params_to_db_snapshot(params: dict) -> dict:
|
||
"""그리드 params(표시 단위) → env_config 컬럼명:값 문자열 dict."""
|
||
field_map = _get_scalp_field_map()
|
||
return {
|
||
db_col: fmt(params[param_k])
|
||
for param_k, (db_col, fmt) in field_map.items()
|
||
if param_k in params
|
||
}
|
||
|
||
|
||
def _apply_from_latest_json(rank: int):
|
||
"""최근 search_*.json에서 rank번째(1-based) 항목의 merged_params를 DB에 적용."""
|
||
latest_path = _latest_json("search_")
|
||
if not latest_path:
|
||
print("⚠️ search_*.json 파일이 없습니다 (신규/구 경로 모두).")
|
||
return
|
||
with open(latest_path, "r", encoding="utf-8") as f:
|
||
data = json.load(f)
|
||
top = data.get("top") or []
|
||
if rank < 1 or rank > len(top):
|
||
print(f"⚠️ 순번 {rank}이(가) 유효하지 않습니다. (1~{len(top)})")
|
||
return
|
||
item = top[rank - 1]
|
||
merged = item.get("merged_params")
|
||
if not merged:
|
||
merged = item.get("params")
|
||
if not merged:
|
||
print("⚠️ 해당 항목에 merged_params/params가 없습니다.")
|
||
return
|
||
if item.get("total_pnl", 0) <= 0:
|
||
print(f"⚠️ {rank}번째 결과는 총손익 ≤ 0 (조건 미충족). DB 미적용. 기존 설정 유지.")
|
||
return
|
||
print(f"📂 {latest_path} 에서 {rank}번째 적용합니다.")
|
||
_apply_to_db(merged)
|
||
|
||
|
||
def _ui_to_engine_params(ui_params: dict) -> dict:
|
||
"""UI 표시용(% 등) → 엔진용 비율 단위. 워커에서 공통 사용."""
|
||
engine_params = dict(ui_params)
|
||
engine_params["sl_pct"] = ui_params["sl_pct"] / 100
|
||
engine_params["tp_pct"] = ui_params["tp_pct"] / 100
|
||
engine_params["drop_rate"] = ui_params["drop_rate"] / 100
|
||
engine_params["trail_trigger"] = ui_params["trail_trigger"] / 100
|
||
engine_params["trail_stop"] = ui_params["trail_stop"] / 100
|
||
engine_params["fee_rate"] = ui_params["fee_rate"] / 100
|
||
engine_params["sell_tax"] = ui_params["sell_tax"] / 100
|
||
engine_params["min_margin"] = ui_params.get("min_margin", 0.2) / 100
|
||
if "use_defense_filters" in ui_params:
|
||
engine_params["use_defense_filters"] = bool(ui_params["use_defense_filters"])
|
||
|
||
# 👇 [핵심] 손절 퍼센트에 맞춰 1회 투자금(slot_money) 자동 계산 (봇과 동일 공식)
|
||
# 5억 고정이면 수수료만으로 손절컷 걸려 좋은 조합(RSI 17 등)이 버려짐 → max_loss_krw/sl_pct 로 보정
|
||
max_loss = engine_params.get("max_loss_krw", 200000)
|
||
if engine_params["sl_pct"] > 0 and max_loss > 0:
|
||
engine_params["slot_money"] = max_loss / engine_params["sl_pct"]
|
||
|
||
return engine_params
|
||
|
||
def _evaluate_scalp_chunk(
|
||
param_chunk: List[Dict[str, Any]],
|
||
base_fixed: Dict[str, Any],
|
||
keys: List[str],
|
||
codes_candles: Dict[str, List[Dict]],
|
||
min_trades: int,
|
||
min_win_rate: float,
|
||
top_n: int,
|
||
universe_by_slot: Optional[Dict[str, List[str]]] = None,
|
||
) -> List[Tuple[float, float, int, Dict]]:
|
||
"""워커: 청크 내 조합 평가 후 승률→수익 순 상위 top_n개만 힙으로 반환.
|
||
universe_by_slot이 있으면 실매매와 동일하게 5분마다 후보 종목만 매수 검사."""
|
||
local_heap: List[Tuple[float, float, int, Dict]] = []
|
||
for combo in param_chunk:
|
||
ui_params = dict(base_fixed)
|
||
ui_params.update(combo)
|
||
engine_params = _ui_to_engine_params(ui_params)
|
||
trades = se.run_scalping_backtest(
|
||
codes_candles, engine_params, universe_by_slot=universe_by_slot
|
||
)
|
||
total_trades = len(trades)
|
||
if total_trades < min_trades:
|
||
continue
|
||
total_pnl = sum(t["pnl"] for t in trades)
|
||
wins = sum(1 for t in trades if t["pnl"] > 0)
|
||
win_rate = (wins / total_trades * 100) if total_trades else 0
|
||
win_pnl = sum(t["pnl"] for t in trades if t["pnl"] > 0)
|
||
loss_pnl = sum(t["pnl"] for t in trades if t["pnl"] < 0)
|
||
pf = round(abs(win_pnl / loss_pnl), 2) if loss_pnl != 0 else 9999.0
|
||
avg_hold = (sum(t["hold_min"] for t in trades) / total_trades) if total_trades else 0
|
||
peak, mdd, cum = 0.0, 0.0, 0.0
|
||
for t in trades:
|
||
cum += t["pnl"]
|
||
if cum > peak: peak = cum
|
||
dd = peak - cum
|
||
if dd > mdd: mdd = dd
|
||
# merged_params = 실제 엔진에 넘긴 값 반영 (slot_money는 손절%에 맞춰 계산된 값 저장)
|
||
merged = dict(ui_params)
|
||
if "slot_money" in engine_params:
|
||
merged["slot_money"] = engine_params["slot_money"]
|
||
result_pkg = {
|
||
"params": {k: ui_params[k] for k in keys},
|
||
"total_pnl": int(total_pnl),
|
||
"win_rate": round(win_rate, 2),
|
||
"total_trades": total_trades,
|
||
"pf": round(pf, 2),
|
||
"avg_hold": round(avg_hold, 1),
|
||
"mdd": round(mdd),
|
||
"merged_params": merged,
|
||
}
|
||
if len(local_heap) < top_n:
|
||
heapq.heappush(local_heap, (win_rate, total_pnl, id(result_pkg), result_pkg))
|
||
else:
|
||
heapq.heappushpop(local_heap, (win_rate, total_pnl, id(result_pkg), result_pkg))
|
||
return local_heap
|
||
|
||
|
||
def _load_candles_for_search(start: str, end: str, rsi_period: int) -> dict:
|
||
"""엔진 직접 타격을 위해 DB에서 캔들을 한 번만 메모리에 로드합니다."""
|
||
db = TradeDB()
|
||
codes_candles = {}
|
||
try:
|
||
start_key = (start.replace("-", "") + "0000") if start else "20260101"
|
||
end_key = (end.replace("-", "") + "2359") if end else "99991231"
|
||
|
||
codes_raw = db.conn.execute(
|
||
"SELECT DISTINCT code FROM ws_candles WHERE timeframe=1 "
|
||
"AND candle_time >= %s AND candle_time <= %s ORDER BY code",
|
||
[start_key, end_key]
|
||
).fetchall()
|
||
codes = [r["code"] for r in codes_raw]
|
||
|
||
for code in codes:
|
||
rows = db.conn.execute(
|
||
"SELECT candle_time, open, high, low, close, volume "
|
||
"FROM ws_candles "
|
||
"WHERE timeframe=1 AND code=%s "
|
||
"AND candle_time >= %s AND candle_time <= %s "
|
||
"AND is_confirmed=1 "
|
||
"ORDER BY candle_time ASC",
|
||
[code, start_key, end_key]
|
||
).fetchall()
|
||
if len(rows) < rsi_period + 5:
|
||
continue
|
||
codes_candles[code] = [dict(r) for r in rows]
|
||
finally:
|
||
db.close()
|
||
return codes_candles
|
||
|
||
|
||
def run_search(start: str, end: str, mode: str, top_n: int,
|
||
min_trades: int, min_win_rate: float, apply_rank: Optional[int], from_file_only: bool,
|
||
sort_by: str = "pnl", use_fallback_universe: bool = False) -> bool:
|
||
"""탐색 실행. 결과가 있어서 JSON 저장까지 했으면 True, 조건 만족 조합 없이 조기 return 시 False."""
|
||
if from_file_only and apply_rank is not None and apply_rank >= 1:
|
||
_apply_from_latest_json(apply_rank)
|
||
return True
|
||
|
||
grid = _scalp_grids()[mode]
|
||
keys = list(grid.keys())
|
||
combos = list(product(*[grid[k] for k in keys]))
|
||
total = len(combos)
|
||
print(f"\n[{mode.upper()} 모드] 탐색 조합: {total:,}개 | 기간: {start} ~ {end}")
|
||
print(f"📌 1위 정렬 기준: {'총손익 최대 (수익 나는 조합 우선)' if sort_by == 'pnl' else '승률 최대'}")
|
||
print("=" * 70)
|
||
|
||
results = []
|
||
t0 = time.time()
|
||
|
||
FIXED_DEFAULTS = _fixed_defaults()
|
||
|
||
# 캔들 데이터를 메모리에 1회 로드 (워커에 전달)
|
||
print("⏳ DB에서 캔들 데이터를 메모리로 불러오는 중...")
|
||
codes_candles = _load_candles_for_search(start, end, FIXED_DEFAULTS.get("rsi_period", 3))
|
||
print(f"✅ 데이터 로드 완료: {len(codes_candles)}종목")
|
||
|
||
# 유니버스: --fallback-universe 이면 이력 무시하고 시뮬레이션만 사용 (조합별 거래 수 확대)
|
||
# 신봇 기준:
|
||
# * 실매매는 10초 REST 폴링 + 변동 tick 마다 초단위 event_time 으로 저장.
|
||
# * 백테스트는 TradeDBExt.get_universe_by_candle_time("SCALP", ...) 로
|
||
# 1분 캔들 시각 키를 가진 dict 로 받아 엔진에 그대로 주입.
|
||
# * fallback 시뮬레이션은 1분봉 근사 점수 기반 5분 버킷팅 (과거 호환).
|
||
universe_by_slot = None
|
||
fallback_sim_interval = 5 # --fallback-universe 전용 시뮬레이션 버킷 (분)
|
||
start_ymd = start.replace("-", "") if start else ""
|
||
end_ymd = end.replace("-", "") if end else ""
|
||
if use_fallback_universe:
|
||
print("📌 [유니버스] --fallback-universe: 저장 이력 무시 → 시뮬레이션 유니버스 (조합별 거래 수 확대)")
|
||
elif start_ymd and end_ymd:
|
||
try:
|
||
# 신봇 이력 (초단위 event_time) → 1분 캔들 시각으로 리샘플링
|
||
from kis_trader.database.db_manager import get_db as _get_ext_db # type: ignore
|
||
_ext = _get_ext_db()
|
||
history = _ext.get_universe_by_candle_time(
|
||
strategy_id="SCALP",
|
||
start_ymd=start_ymd,
|
||
end_ymd=end_ymd,
|
||
)
|
||
if history:
|
||
universe_by_slot = history
|
||
n_bins = len(history)
|
||
avg = sum(len(v) for v in history.values()) / max(1, n_bins)
|
||
print(
|
||
f"✅ 유니버스: 신봇 이력 사용 (event_time → 1분 캔들 리샘플링) | "
|
||
f"{n_bins:,}분봉 · 평균 {avg:.1f}종목 (SCALP)"
|
||
)
|
||
print(
|
||
"📌 [유니버스] 이력만 쓰면 매수 기회 적어 거래 0~1건 나올 수 있음. "
|
||
"조합 많을 때는 --fallback-universe 권장."
|
||
)
|
||
else:
|
||
universe_by_slot = None
|
||
except Exception as _e:
|
||
logging.getLogger("param_search").debug(
|
||
"신봇 유니버스 이력 조회 스킵: %s", _e,
|
||
)
|
||
universe_by_slot = None
|
||
# 엔진이 쓸 슬롯 단위 결정:
|
||
# * 신봇 이력 경로 → 1분봉 키(=passthrough)
|
||
# * 시뮬 fallback → fallback_sim_interval 분 버킷
|
||
engine_scan_interval_min = 1
|
||
if universe_by_slot is None:
|
||
universe_top_n = int(os.environ.get("UPDATE_UNIVERSE_TOP_N", "20"))
|
||
universe_min_score = float(os.environ.get("UPDATE_UNIVERSE_MIN_SCORE", "4.0"))
|
||
universe_by_slot = se.build_universe_simulation(
|
||
codes_candles,
|
||
top_n=universe_top_n,
|
||
min_score=universe_min_score,
|
||
scan_interval_min=fallback_sim_interval,
|
||
)
|
||
engine_scan_interval_min = fallback_sim_interval
|
||
n_slots = len(universe_by_slot)
|
||
avg_per_slot = sum(len(c) for c in universe_by_slot.values()) / max(1, n_slots)
|
||
print(
|
||
f"✅ 유니버스: 시뮬레이션 사용 (이력 없음) | "
|
||
f"{fallback_sim_interval}분 슬롯 {n_slots}개 · 슬롯당 평균 {avg_per_slot:.1f}종목"
|
||
)
|
||
print("📌 [유니버스] 서치는 '시뮬레이션 유니버스' 기준입니다. (신봇 이력 없음)")
|
||
|
||
# 엔진에 슬롯 단위 주입 (engine._slot_key 가 이 값으로 캔들 시각 정규화)
|
||
FIXED_DEFAULTS["scan_interval_min"] = engine_scan_interval_min
|
||
|
||
# 조합을 딕셔너리 리스트로 변환 후 청크 분할
|
||
dict_combos = [dict(zip(keys, c)) for c in combos]
|
||
n_cpu = os.cpu_count() or 4
|
||
# 스캘핑·꼬리잡기 두 서치를 동시에 돌려도 합산 80% 가 되도록 40% 로 유지.
|
||
# (단독 실행 시 CPU 절반 놀지만, 하루 1회 자동 최적화 파이프라인 보호가 우선)
|
||
max_workers = max(1, int(n_cpu * 0.4))
|
||
|
||
# [핵심 수정] 청크 크기를 최대 300개로 제한하여 진행률 표시가 실시간으로 업데이트되도록 함
|
||
chunk_size = min(300, max(50, total // (max_workers * 4)))
|
||
chunks = [dict_combos[i:i + chunk_size] for i in range(0, len(dict_combos), chunk_size)]
|
||
|
||
print(f"⚙️ 멀티프로세싱 시작 (코어: {n_cpu}, 워커: {max_workers} ≈ 80%%) | 청크: {len(chunks):,}개")
|
||
|
||
start_time = time.time()
|
||
global_heap: List[Tuple[float, float, Tuple[int, int], Dict]] = []
|
||
|
||
# initializer=_worker_init 로 워커에게 PR_SET_PDEATHSIG 설정
|
||
# → 부모가 SIGKILL·SIGTERM 어느 경로로 죽어도 워커가 고아로 남지 않음.
|
||
with ProcessPoolExecutor(max_workers=max_workers, initializer=_worker_init) as executor:
|
||
futures = {
|
||
executor.submit(
|
||
_evaluate_scalp_chunk, chunk, FIXED_DEFAULTS, keys, codes_candles,
|
||
min_trades, min_win_rate, top_n, universe_by_slot
|
||
): chunk for chunk in chunks
|
||
}
|
||
|
||
combos_per_chunk = chunk_size
|
||
print(f"⏳ 청크 처리 중… (청크당 최대 {combos_per_chunk:,}개 조합, 완료되는 대로 진행률·ETA 출력)")
|
||
|
||
processed = 0
|
||
use_carriage_return = sys.stdout.isatty()
|
||
|
||
for future in as_completed(futures):
|
||
processed += 1
|
||
local_results = future.result()
|
||
|
||
for i, item in enumerate(local_results):
|
||
wr, pnl, _, result_pkg = item
|
||
# sort_by pnl: 1위 = 총손익 최대 (－pnl 로 넣어서 min-heap에서 수익 큰 게 뒤로)
|
||
# sort_by win_rate: 1위 = 승률 최대 (기존)
|
||
if sort_by == "pnl":
|
||
unique_item = (-pnl, wr, (processed, i), result_pkg)
|
||
else:
|
||
unique_item = (wr, pnl, (processed, i), result_pkg)
|
||
if len(global_heap) < top_n:
|
||
heapq.heappush(global_heap, unique_item)
|
||
else:
|
||
heapq.heappushpop(global_heap, unique_item)
|
||
|
||
# ── 정확한 ETA(예상 남은 시간) 계산 로직 ──
|
||
progress = (processed / len(chunks)) * 100
|
||
elapsed_so_far = time.time() - start_time
|
||
|
||
# 누적 소요 시간을 처리된 청크 개수로 나누어 1청크당 평균 처리 시간 도출
|
||
avg_time_per_chunk = elapsed_so_far / processed
|
||
remaining_chunks = len(chunks) - processed
|
||
eta_sec = avg_time_per_chunk * remaining_chunks
|
||
|
||
# 초 단위 포맷팅 (시간/분/초)
|
||
eta_m, eta_s = divmod(int(eta_sec), 60)
|
||
eta_h, eta_m = divmod(eta_m, 60)
|
||
if eta_h > 0:
|
||
eta_str = f"{eta_h}시간 {eta_m}분 {eta_s}초"
|
||
elif eta_m > 0:
|
||
eta_str = f"{eta_m}분 {eta_s}초"
|
||
else:
|
||
eta_str = f"{eta_s}초"
|
||
|
||
elapsed_m, elapsed_s = divmod(int(elapsed_so_far), 60)
|
||
|
||
eta_msg = f" | 경과: {elapsed_m}분 {elapsed_s}초 | 남은시간: {eta_str}"
|
||
line = f"⏳ 진행률: {progress:.1f}% ({processed:,}/{len(chunks):,} 청크 완료){eta_msg}"
|
||
|
||
if use_carriage_return:
|
||
print(f"\r{line}", end="", flush=True)
|
||
else:
|
||
print(line, flush=True)
|
||
|
||
if use_carriage_return:
|
||
print(flush=True) # 줄바꿈으로 진행률 줄 마무리
|
||
|
||
elapsed = time.time() - start_time
|
||
|
||
if not global_heap:
|
||
print("⚠️ 조건을 만족하는 조합이 없습니다. (min_trades를 낮추거나 기간을 늘려보세요.)")
|
||
print("📌 DB 미적용. 기존 설정 유지.")
|
||
return False
|
||
|
||
# 힙: sort_by pnl → (-pnl, wr) 최소힙 → heappop 순이 이미 [best pnl, ..., worst] 이므로 reverse 금지
|
||
# sort_by win_rate → (wr, pnl) 최소힙 → heappop 순은 [low wr, ..., high wr] 이므로 reverse 필요
|
||
results = [heapq.heappop(global_heap)[3] for _ in range(len(global_heap))]
|
||
if sort_by == "win_rate":
|
||
results.reverse()
|
||
|
||
# RSI_OVERSOLD 기준으로 균등 분배 → JSON에 RSI별 PER_RSI_JSON개씩 (한 RSI에 치중 방지)
|
||
if "rsi_oversold" in keys and results:
|
||
rsi_vals = sorted(set(r["params"]["rsi_oversold"] for r in results))
|
||
by_rsi: Dict[Any, List[Dict]] = {}
|
||
for r in results:
|
||
v = r["params"]["rsi_oversold"]
|
||
if v not in by_rsi:
|
||
by_rsi[v] = []
|
||
if len(by_rsi[v]) < PER_RSI_JSON:
|
||
by_rsi[v].append(r)
|
||
results = []
|
||
for v in rsi_vals:
|
||
results.extend(by_rsi.get(v, []))
|
||
# 손익 순 유지, 동점이면 RSI 낮은 쪽(과매도 강함) 우선
|
||
results.sort(key=lambda r: (-r["total_pnl"], r["params"]["rsi_oversold"], -r["win_rate"]))
|
||
print(f"✅ RSI별 상위 {PER_RSI_JSON}개씩 보장 → {len(results)}건 (총 {len(rsi_vals)}가지 RSI)")
|
||
|
||
# 승률 min_win_rate 이상만 우선; 없으면 차악
|
||
filtered = [r for r in results if r["win_rate"] >= min_win_rate]
|
||
if filtered:
|
||
results = filtered
|
||
order_msg = "수익→승률 순" if sort_by == "pnl" else "승률→수익 순"
|
||
print(f"✅ 승률 {min_win_rate}% 이상 {len(results)}건 중 {order_msg} 상위 사용")
|
||
else:
|
||
print(f"⚠️ 승률 {min_win_rate}% 이상 없음 → 차악(상위) 적용")
|
||
|
||
# 손익 마이너스인 조합 제외 (수익 나는 것만 표시·저장)
|
||
profitable = [r for r in results if r["total_pnl"] > 0]
|
||
if profitable:
|
||
results = profitable
|
||
print(f"✅ 총손익 플러스만 사용: {len(results)}건 (손실 조합 제외)")
|
||
else:
|
||
print(f"⚠️ 수익 나는 조합 없음 → 손실 최소 순으로 표시")
|
||
|
||
print(f"\n완료: {elapsed:.1f}초 | 유효 결과: {len(results)}건")
|
||
|
||
# ── 결과 출력 ──
|
||
hdr_keys = [k for k in keys]
|
||
col_w = max(len(k) for k in hdr_keys) + 2
|
||
|
||
order_label = "수익" if sort_by == "pnl" else "승률"
|
||
print(f"\n{'='*90}")
|
||
print(f" 🏆 {order_label} TOP {min(top_n, len(results))} (투자금 1,000,000원 기준)")
|
||
print(f"{'='*90}")
|
||
|
||
# 헤더
|
||
hdr = " ".join(f"{k:>{col_w}}" for k in hdr_keys)
|
||
print(f"{hdr} | {'손익(원)':>12} {'승률':>6} {'거래':>5} {'PF':>5} {'보유':>6}")
|
||
print("-" * (len(hdr) + 55))
|
||
|
||
for r in results[:top_n]:
|
||
p = r["params"]
|
||
row = " ".join(
|
||
(f"{str(p[k]):>{col_w}}" if isinstance(p[k], bool) else f"{p[k]:>{col_w}.4g}")
|
||
for k in hdr_keys
|
||
)
|
||
print(f"{row} | {r['total_pnl']:>+12,.0f} {r['win_rate']:>5.1f}% "
|
||
f"{r['total_trades']:>5} {r['pf']:>5.2f} {r['avg_hold']:>5.1f}분")
|
||
|
||
best = results[0]
|
||
bp = best["params"]
|
||
print(f"""
|
||
╔══════════════════════════════════════════╗
|
||
║ 🏆 1위 최적 파라미터 ║
|
||
╠══════════════════════════════════════════╣""")
|
||
|
||
_disp_map = {
|
||
"rsi_oversold": "SCALP_RSI_OVERSOLD",
|
||
"rsi_overbought": "SCALP_RSI_OVERBOUGHT",
|
||
"sl_pct": "SCALP_STOP_LOSS_PCT (÷100)",
|
||
"tp_pct": "SCALP_TAKE_PROFIT_PCT(÷100)",
|
||
"drop_rate": "SCALP_MIN_DROP_RATE (÷100)",
|
||
"trail_trigger": "SCALP_ATR_UP_MULT (트레일발동%)",
|
||
"trail_stop": "SCALP_ATR_DOWN_MULT(트레일추적%)",
|
||
"cooldown_min": "SCALP_COOLDOWN_SEC(÷60=분)",
|
||
"high_chase_thr": "HIGH_PRICE_CHASE_THRESHOLD",
|
||
"max_daily_chg": "MAX_DAILY_CHANGE_PCT",
|
||
"max_loss_krw": "MAX_LOSS_PER_TRADE_KRW(원)",
|
||
"min_price": "SCALP_MIN_PRICE(원)",
|
||
"use_defense_filters": "SCALP_USE_DEFENSE_FILTERS",
|
||
}
|
||
|
||
for k, v in bp.items():
|
||
label = _disp_map.get(k, k)
|
||
print(f"║ {label:<30s} : {v!s:>6} ║")
|
||
print(f"""╠══════════════════════════════════════════╣
|
||
║ 총 손익 : {best['total_pnl']:>+12,.0f} 원 ║
|
||
║ 승률 : {best['win_rate']:>6.1f}% ║
|
||
║ 총 거래 : {best['total_trades']:>5} 건 ║
|
||
║ Profit Factor : {best['pf']:>5.2f} ║
|
||
║ 평균 보유 : {best['avg_hold']:>5.1f} 분 ║
|
||
║ 최대 낙폭(MDD): {best['mdd']:>12,.0f} 원 ║
|
||
╚══════════════════════════════════════════╝""")
|
||
|
||
# JSON 저장용: RSI별 200개씩 모은 전체 리스트 (콘솔 TOP은 여전히 top_n만 출력)
|
||
top_list = []
|
||
for idx, r in enumerate(results):
|
||
p = r["params"]
|
||
merged = r.get("merged_params", p)
|
||
top_list.append({
|
||
"rank": idx + 1,
|
||
"params": p,
|
||
"merged_params": merged,
|
||
"db_snapshot": _params_to_db_snapshot(merged),
|
||
"total_pnl": r["total_pnl"],
|
||
"win_rate": r["win_rate"],
|
||
"total_trades": r["total_trades"],
|
||
"pf": r["pf"],
|
||
"avg_hold": r["avg_hold"],
|
||
"mdd": r["mdd"],
|
||
})
|
||
|
||
# ── JSON 결과 저장 (kis_trader/backtest/results/) ──
|
||
# 권한 문제 대비: 쓰기 실패 시 사용자 홈(~/.kis_bot_search_results/)으로 폴백.
|
||
out_dir = _results_dir_for_write()
|
||
ts = datetime.now().strftime("%Y%m%d_%H%M%S")
|
||
out_path = os.path.join(out_dir, f"search_{mode}_{ts}.json")
|
||
payload = {
|
||
"mode": mode,
|
||
"start": start,
|
||
"end": end,
|
||
"min_win_rate": min_win_rate,
|
||
"top": top_list,
|
||
}
|
||
try:
|
||
with open(out_path, "w", encoding="utf-8") as f:
|
||
json.dump(payload, f, ensure_ascii=False, indent=2)
|
||
print(f"\n💾 결과 저장: {out_path}")
|
||
except (PermissionError, OSError) as _e:
|
||
fallback_dir = os.path.join(os.path.expanduser("~"), ".kis_bot_search_results")
|
||
os.makedirs(fallback_dir, exist_ok=True)
|
||
out_path = os.path.join(fallback_dir, f"search_{mode}_{ts}.json")
|
||
with open(out_path, "w", encoding="utf-8") as f:
|
||
json.dump(payload, f, ensure_ascii=False, indent=2)
|
||
print(f"\n⚠️ 기본 경로({out_dir}) 쓰기 실패({type(_e).__name__}). 폴백 저장: {out_path}")
|
||
print(f" 권한 복구: sudo chown -R $USER:$USER {out_dir}")
|
||
|
||
# ── DB 자동 적용 (만족 조건: 총손익 > 0. 미충족 시 기존 설정 유지) ──
|
||
if apply_rank is not None and apply_rank >= 1 and apply_rank <= len(top_list):
|
||
cand = top_list[apply_rank - 1]
|
||
if cand.get("total_pnl", 0) <= 0:
|
||
print(f"⚠️ {apply_rank}번째 결과는 총손익 ≤ 0 (조건 미충족). DB 미적용. 기존 설정 유지.")
|
||
else:
|
||
_apply_to_db(cand["merged_params"])
|
||
print(f"✅ {apply_rank}번째 결과 적용 완료")
|
||
|
||
return True
|
||
|
||
|
||
def _apply_to_db(best_params: dict):
|
||
"""1위 파라미터를 env_config DB에 자동 반영."""
|
||
field_map = _get_scalp_field_map()
|
||
|
||
sets = []
|
||
vals = []
|
||
for param_k, val in best_params.items():
|
||
if param_k not in field_map:
|
||
continue
|
||
db_col, fmt = field_map[param_k]
|
||
sets.append(f"{db_col} = %s")
|
||
vals.append(fmt(val))
|
||
|
||
if not sets:
|
||
print("DB 적용할 파라미터가 없습니다.")
|
||
return
|
||
|
||
db = TradeDB()
|
||
db.conn.execute(f"UPDATE env_config SET {', '.join(sets)}", vals)
|
||
db.conn.commit()
|
||
db.close()
|
||
print("\n✅ DB env_config 자동 적용 완료:")
|
||
for param_k, val in best_params.items():
|
||
if param_k in field_map:
|
||
db_col, fmt = field_map[param_k]
|
||
print(f" {db_col:<30s} = {fmt(val)}")
|
||
|
||
|
||
# ──────────────────────────────────────────────────────────────────────────────
|
||
# CLI 진입점
|
||
# ──────────────────────────────────────────────────────────────────────────────
|
||
|
||
def main():
|
||
today = datetime.now().strftime("%Y-%m-%d")
|
||
week_ago = (datetime.now() - timedelta(days=7)).strftime("%Y-%m-%d")
|
||
|
||
parser = argparse.ArgumentParser(description="스캘핑 백테스트 파라미터 Grid Search")
|
||
parser.add_argument("--start", default=week_ago, help="시작일 (YYYY-MM-DD)")
|
||
parser.add_argument("--end", default=today, help="종료일 (YYYY-MM-DD)")
|
||
parser.add_argument("--mode", default="coarse", choices=["coarse", "fine", "full", "wide"],
|
||
help="탐색 모드: coarse / fine / full / wide(방어·min_price 광범위)")
|
||
parser.add_argument("--top", default=5000, type=int, help="상위 N개 출력·JSON 저장 (기본 5000)")
|
||
parser.add_argument("--min_trades", default=1, type=int, help="최소 거래 건수")
|
||
parser.add_argument("--min_win_rate", default=MIN_WIN_RATE_DEFAULT, type=float, help="승률 하한 (%%). 이 이상만 손익순 1위")
|
||
parser.add_argument("--apply", nargs="?", const=1, type=int, default=None, metavar="N",
|
||
help="N번째 결과를 DB에 적용 (기본 1). --from-file 시 최근 JSON에서 적용")
|
||
parser.add_argument("--from-file", action="store_true", help="--apply N 과 함께 사용 시, 최근 결과 JSON에서만 적용 (탐색 생략)")
|
||
parser.add_argument("--sort-by", default="pnl", choices=["pnl", "win_rate"],
|
||
help="1위 기준: pnl=총손익 최대(기본), win_rate=승률 최대")
|
||
parser.add_argument("--fallback-universe", action="store_true", dest="fallback_universe",
|
||
help="저장 이력 무시, 시뮬레이션 유니버스만 사용. 조합 많을 때 거래 수 확대용")
|
||
parser.add_argument("--apply-ai", action="store_true", dest="apply_ai",
|
||
help="Gemini가 수익·승률 기준으로 하나 골라 DB 적용. --from-file 과 함께 쓰면 탐색 없이 최근 JSON만 사용; 그 외에는 탐색 완료 후 방금 생성된 JSON으로 적용")
|
||
args = parser.parse_args()
|
||
|
||
# 탐색 없이 최근 JSON으로만 AI 적용 (--from-file --apply-ai)
|
||
if args.apply_ai and args.from_file:
|
||
import param_apply_ai
|
||
param_apply_ai.apply_ai_scalp()
|
||
return
|
||
|
||
# SIGTERM 을 KeyboardInterrupt 와 동일하게 처리 (systemd·운영자 kill 대응)
|
||
def _sigterm_to_kbd(_sig, _frm):
|
||
raise KeyboardInterrupt("SIGTERM 수신 → 워커 정리 후 종료")
|
||
try:
|
||
signal.signal(signal.SIGTERM, _sigterm_to_kbd)
|
||
except Exception:
|
||
pass
|
||
|
||
try:
|
||
had_results = run_search(
|
||
start = args.start,
|
||
end = args.end,
|
||
mode = args.mode,
|
||
top_n = args.top,
|
||
min_trades = args.min_trades,
|
||
min_win_rate = args.min_win_rate,
|
||
apply_rank = args.apply,
|
||
from_file_only = args.from_file,
|
||
sort_by = args.sort_by,
|
||
use_fallback_universe = args.fallback_universe,
|
||
)
|
||
except KeyboardInterrupt as e:
|
||
# ProcessPoolExecutor 의 `with ... as executor:` 블록이 __exit__ 시
|
||
# shutdown(wait=True) 을 호출하고, 워커들은 PR_SET_PDEATHSIG 로 이미
|
||
# SIGTERM 을 받은 상태라 빠르게 정리된다.
|
||
print(f"\n⛔ {e} — 미완료 결과 없이 종료합니다.", flush=True)
|
||
sys.exit(130) # 130 = SIGINT 관례 exit code
|
||
|
||
# 탐색에서 조건 만족 조합이 있었을 때만 방금 저장된 JSON으로 AI 적용 (없으면 기존 설정 유지)
|
||
if args.apply_ai and had_results:
|
||
import param_apply_ai
|
||
param_apply_ai.apply_ai_scalp()
|
||
elif args.apply_ai and not had_results:
|
||
print("📌 이번 탐색에서 조건 만족 조합 없음 → apply_ai 스킵. DB 미적용. 기존 설정 유지.")
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|