268 lines
9.0 KiB
Python
268 lines
9.0 KiB
Python
"""
|
|
kis_trader/backtest/optuna_whipsaw_recommend.py
|
|
=================================================
|
|
Optuna 차트 캔들 최적화 완료 후, 후처리로 고속 휩쏘 파라미터 탐색을 수행하여
|
|
전략별 최적의 휩쏘 필터 수치(Consensus)를 도출하고
|
|
Optuna out_data 및 Apply 패치에 자동으로 결합하는 모듈입니다.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
from dataclasses import dataclass
|
|
from datetime import datetime, timedelta
|
|
from typing import Any, Dict, List, Optional, Tuple
|
|
|
|
import optuna
|
|
|
|
from database import TradeDB
|
|
from kis_trader.engine.whipsaw_filter import whipsaw_reject_for_signal
|
|
|
|
logger = logging.getLogger("OptunaWhipsawRecommend")
|
|
optuna.logging.set_verbosity(optuna.logging.WARNING)
|
|
|
|
|
|
@dataclass
|
|
class TradeInfo:
|
|
code: str
|
|
name: str
|
|
buy_dt: datetime
|
|
buy_price: float
|
|
actual_pnl: float
|
|
actual_profit_rate: float
|
|
ticks: List[Dict[str, Any]]
|
|
|
|
|
|
def recommend_whipsaw_parameters(
|
|
*,
|
|
strategy: str = "MOMENTUM",
|
|
n_trials: int = 500,
|
|
days: int = 7,
|
|
log: Optional[logging.Logger] = None,
|
|
) -> Dict[str, Any]:
|
|
lg = log or logger
|
|
strat_upper = str(strategy).strip().upper()
|
|
|
|
db = TradeDB()
|
|
try:
|
|
now = datetime.now()
|
|
start_date = (now - timedelta(days=days)).strftime("%Y-%m-%d")
|
|
|
|
buys = db.conn.execute(
|
|
"""
|
|
SELECT id, code, name, buy_date, buy_price, realized_pnl, profit_rate
|
|
FROM trade_history
|
|
WHERE strategy=%s AND DATE(buy_date) >= %s
|
|
ORDER BY buy_date
|
|
""",
|
|
(strat_upper, start_date),
|
|
).fetchall()
|
|
|
|
trades: List[TradeInfo] = []
|
|
for b in buys:
|
|
code = b["code"]
|
|
raw_dt = b["buy_date"]
|
|
if isinstance(raw_dt, str):
|
|
try:
|
|
buy_dt = datetime.strptime(raw_dt, "%Y-%m-%d %H:%M:%S")
|
|
except ValueError:
|
|
buy_dt = datetime.fromisoformat(raw_dt)
|
|
else:
|
|
buy_dt = raw_dt
|
|
|
|
buy_price = float(b["buy_price"] or 0)
|
|
pnl = float(b["realized_pnl"] or 0)
|
|
rate = float(b["profit_rate"] or 0)
|
|
|
|
start_tick_time = (buy_dt - timedelta(seconds=180)).strftime("%Y%m%d%H%M%S")
|
|
end_tick_time = buy_dt.strftime("%Y%m%d%H%M%S")
|
|
|
|
ticks = db.get_ws_ticks(code, market="KR", start_tick_time=start_tick_time, end_tick_time=end_tick_time)
|
|
if not ticks:
|
|
continue
|
|
|
|
trades.append(
|
|
TradeInfo(
|
|
code=code,
|
|
name=str(b.get("name") or code),
|
|
buy_dt=buy_dt,
|
|
buy_price=buy_price,
|
|
actual_pnl=pnl,
|
|
actual_profit_rate=rate,
|
|
ticks=ticks,
|
|
)
|
|
)
|
|
|
|
finally:
|
|
db.close()
|
|
|
|
if len(trades) < 3:
|
|
lg.warning("⚠️ [%s] 휩쏘 연산 가능한 실제 틱 보유 매수 건수(%s건)가 부족하여 최적화 생략.", strat_upper, len(trades))
|
|
return {"ok": False, "reason": "not_enough_trades", "trade_count": len(trades)}
|
|
|
|
orig_cnt = len(trades)
|
|
orig_win = sum(1 for t in trades if t.actual_pnl > 0) / orig_cnt * 100.0
|
|
orig_pnl = sum(t.actual_pnl for t in trades)
|
|
orig_rate = sum(t.actual_profit_rate for t in trades) / orig_cnt
|
|
|
|
def _sim_trade(tr: TradeInfo, p: Dict[str, Any]) -> Tuple[float, float, str]:
|
|
params_for_eval = {
|
|
"whipsaw_filter_enabled": True,
|
|
"whipsaw_subbar_sec": p["subbar_sec"],
|
|
"whipsaw_lookback_sec": p["lookback_sec"],
|
|
"whipsaw_dip_pct": p["dip_pct"],
|
|
"whipsaw_recovery_tol_pct": p.get("recov_pct", 0.0),
|
|
}
|
|
|
|
sig_bar = {"low": tr.buy_price, "dt": tr.buy_dt}
|
|
reject_reason, _ = whipsaw_reject_for_signal(
|
|
params=params_for_eval,
|
|
strategy=strat_upper,
|
|
signal_bar=sig_bar,
|
|
current_price=tr.buy_price,
|
|
ticks=tr.ticks
|
|
)
|
|
|
|
if reject_reason:
|
|
return (0.0, 0.0, "ENTRY_REJECTED")
|
|
|
|
return (tr.actual_pnl, tr.actual_profit_rate, "ORIGINAL")
|
|
|
|
def _calc_suite(p: Dict[str, Any]) -> Tuple[int, float, float, float]:
|
|
t_cnt = 0
|
|
w_cnt = 0
|
|
tot_pnl = 0.0
|
|
tot_rate = 0.0
|
|
for t in trades:
|
|
pnl, rate, rtype = _sim_trade(t, p)
|
|
if rtype != "ENTRY_REJECTED":
|
|
t_cnt += 1
|
|
tot_pnl += pnl
|
|
tot_rate += rate
|
|
if pnl > 0:
|
|
w_cnt += 1
|
|
w_rate = (w_cnt / t_cnt * 100.0) if t_cnt > 0 else 0.0
|
|
avg_r = (tot_rate / t_cnt) if t_cnt > 0 else 0.0
|
|
return t_cnt, w_rate, tot_pnl, avg_r
|
|
|
|
valid_records: List[Dict[str, Any]] = []
|
|
|
|
def obj_func(trial: optuna.Trial) -> float:
|
|
params = {
|
|
"subbar_sec": trial.suggest_categorical("subbar_sec", [10, 15, 20, 30, 45, 60]),
|
|
"lookback_sec": trial.suggest_categorical("lookback_sec", [30, 45, 60, 90, 120, 180]),
|
|
"dip_pct": trial.suggest_float("dip_pct", 0.001, 0.010, step=0.001),
|
|
}
|
|
|
|
cnt, win_r, pnl, rate = _calc_suite(params)
|
|
if cnt < max(3, int(orig_cnt * 0.3)):
|
|
return -999999999.0
|
|
|
|
w_p = (pnl / 100000.0)
|
|
w_w = win_r * 2.0
|
|
score = w_p + w_w
|
|
if win_r >= 60.0:
|
|
score += (win_r - 60.0) * 1.5
|
|
|
|
valid_records.append({"score": score, "pnl": pnl, "win_rate": win_r, "count": cnt, "rate": rate, "params": params})
|
|
return score
|
|
|
|
study = optuna.create_study(direction="maximize")
|
|
study.optimize(obj_func, n_trials=n_trials)
|
|
|
|
valid_records.sort(key=lambda x: x["score"], reverse=True)
|
|
top5 = valid_records[: min(5, len(valid_records))]
|
|
if not top5:
|
|
return {"ok": False, "reason": "no_valid_trials"}
|
|
|
|
# Consensus 도출
|
|
best = top5[0]
|
|
avg_subbar = int(sum(r["params"]["subbar_sec"] for r in top5) / len(top5))
|
|
avg_lookback = int(sum(r["params"]["lookback_sec"] for r in top5) / len(top5))
|
|
avg_dip = round(sum(r["params"]["dip_pct"] for r in top5) / len(top5), 4)
|
|
|
|
cons_params = {
|
|
"subbar_sec": avg_subbar,
|
|
"lookback_sec": avg_lookback,
|
|
"dip_pct": avg_dip,
|
|
}
|
|
c_cnt, c_win, c_pnl, c_rate = _calc_suite(cons_params)
|
|
|
|
lg.info(
|
|
"⚡ [휩쏘 필터 합의 추천] 전략=%s (모수=%d건, %d회 탐색) | subbar=%d lookback=%d dip=%.3f | 승률: %.1f%% 손익: %.0f원",
|
|
strat_upper,
|
|
len(trades),
|
|
n_trials,
|
|
avg_subbar,
|
|
avg_lookback,
|
|
avg_dip,
|
|
c_win,
|
|
c_pnl,
|
|
)
|
|
|
|
return {
|
|
"ok": True,
|
|
"strategy": strat_upper,
|
|
"n_trials": n_trials,
|
|
"trade_count": len(trades),
|
|
"orig_stats": {"count": orig_cnt, "win_rate": round(orig_win, 1), "pnl": orig_pnl, "avg_rate": round(orig_rate, 2)},
|
|
"recommended_stats": {"count": c_cnt, "win_rate": round(c_win, 1), "pnl": c_pnl, "avg_rate": round(c_rate, 2), "pnl_diff": c_pnl - orig_pnl},
|
|
"params": {
|
|
"whipsaw_filter_enabled": True,
|
|
"whipsaw_subbar_sec": avg_subbar,
|
|
"whipsaw_lookback_sec": avg_lookback,
|
|
"whipsaw_dip_pct": avg_dip,
|
|
},
|
|
}
|
|
|
|
|
|
def attach_whipsaw_recommend(
|
|
out_data: Dict[str, Any],
|
|
*,
|
|
log: Optional[logging.Logger] = None,
|
|
) -> Dict[str, Any]:
|
|
"""out_data에 휩쏘 필터 추천 결과를 첨부."""
|
|
lg = log or logger
|
|
strat = str(out_data.get("strategy") or "MOMENTUM").strip().upper()
|
|
rec = recommend_whipsaw_parameters(strategy=strat, n_trials=500, log=lg)
|
|
out_data["whipsaw_recommend"] = rec
|
|
mc = out_data.get("mode_combo")
|
|
if isinstance(mc, dict):
|
|
mc["whipsaw_recommend"] = rec
|
|
if not rec.get("ok"):
|
|
lg.info("⚡ [휩쏘 필터 합의 추천] 생략 — %s", rec.get("reason") or "n/a")
|
|
return out_data
|
|
|
|
|
|
_WHIPSAW_DB_SKIP_STRATS = {"TAIL", "SHORT", "BREAKOUT"}
|
|
|
|
|
|
def build_whipsaw_env_patch(rec: Dict[str, Any]) -> Dict[str, str]:
|
|
"""휩쏘 추천 결과를 DB env 패치 dict로 변환."""
|
|
if not rec or not rec.get("ok"):
|
|
return {}
|
|
|
|
strat = str(rec.get("strategy") or "").strip().upper()
|
|
pfx = "TAIL" if strat in ("SHORT", "TAIL") else strat
|
|
p = rec.get("params", {})
|
|
if not pfx or not p:
|
|
return {}
|
|
|
|
if strat in _WHIPSAW_DB_SKIP_STRATS:
|
|
logger.info(
|
|
"🚫 [%s] 휩쏘 필터 DB 적용 차단 (전략 특성상 UI 표시만) — 수치: subbar=%s lookback=%s dip=%s",
|
|
strat,
|
|
p.get('whipsaw_subbar_sec'),
|
|
p.get('whipsaw_lookback_sec'),
|
|
p.get('whipsaw_dip_pct'),
|
|
)
|
|
return {}
|
|
|
|
patch = {
|
|
f"{pfx}_WHIPSAW_FILTER_ENABLED": "true",
|
|
f"{pfx}_WHIPSAW_SUBBAR_SEC": str(p["whipsaw_subbar_sec"]),
|
|
f"{pfx}_WHIPSAW_LOOKBACK_SEC": str(p["whipsaw_lookback_sec"]),
|
|
f"{pfx}_WHIPSAW_DIP_PCT": str(p["whipsaw_dip_pct"]),
|
|
}
|
|
return patch
|