c6888c9228
초기 자금 GT_INITIAL_CASH_KRW=400000과 원화 한도 비율(알림·LIVE_ORDER·일한도·손실한도)을 맞추고, dry-run/live 체결을 sim_causal_hybrid(replay)와 동일 경로로 통합한다. 시뮬 리포트 갱신, Phase C 슈퍼바이저·매수매도 리허설 스크립트를 추가한다. Co-authored-by: Cursor <cursoragent@cursor.com>
950 lines
34 KiB
Python
950 lines
34 KiB
Python
"""
|
|
1단계: walk-forward·민감도·실거래 한도 가정 시뮬·Go/No-Go 리포트.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
import numpy as np
|
|
import pandas as pd
|
|
|
|
from config import (
|
|
GT_INITIAL_CASH_KRW,
|
|
LIVE_ORDER_KRW,
|
|
LIVE_SLIPPAGE_PCT,
|
|
MATCH_HOLDOUT_RATIO,
|
|
MATCH_MIN_EV_VALID,
|
|
MATCH_MIN_FIRES_HOLDOUT,
|
|
MATCH_MIN_PROFIT_FACTOR,
|
|
MATCH_TRAIN_RATIO,
|
|
SIM_FEE_STRESS_MULT,
|
|
SIM_GO_MIN_HOLDOUT_EV,
|
|
SIM_GO_MIN_HOLDOUT_PF,
|
|
SIM_GO_WF_POSITIVE_RATIO,
|
|
SIM_HYBRID_MAX_MDD_PCT,
|
|
SIM_HYBRID_MIN_HOLDOUT_PNL_PCT,
|
|
SIM_OPTION_C_MIN_GT_CAPTURE,
|
|
SIM_OPTION_C_PHASE2_FEE_STRESS_RATIO,
|
|
SIM_OPTION_C_PHASE2_TARGET_PNL_PCT,
|
|
SIM_OPTION_C_TARGET_PNL_PCT,
|
|
SIM_WALK_FORWARD_MIN_MONTHS,
|
|
TRADING_FEE_RATE,
|
|
)
|
|
from deepcoin.ground_truth.ground_truth import (
|
|
load_ground_truth,
|
|
order_trades_chronological,
|
|
)
|
|
from deepcoin.ground_truth.gt_allocation import simulate_portfolio_summary
|
|
from deepcoin.ground_truth.gt_model import (
|
|
default_model,
|
|
model_to_dict,
|
|
summarize_leg_weights,
|
|
weight_policy_summary,
|
|
)
|
|
from deepcoin.matching.portfolio_sim import (
|
|
fires_to_trade_list,
|
|
simulate_fixed_order_portfolio,
|
|
simulate_sized_portfolio,
|
|
sort_fires_chronological,
|
|
)
|
|
from deepcoin.matching.select_rules import _rule_metrics, _split_train_valid_holdout
|
|
from deepcoin.paths import resolve_ground_truth_file
|
|
from deepcoin.paths import (
|
|
ANALYSIS_GT_CALIBRATION_JSON,
|
|
MATCHING_FIRE_OUTCOMES,
|
|
MATCHING_MATCHED_RULES,
|
|
MATCHING_SIMULATION_HTML,
|
|
MATCHING_SIMULATION_JSON,
|
|
resolve_ground_truth_file,
|
|
)
|
|
|
|
|
|
def _fee_adjust_ret(series: pd.Series, mult: float) -> pd.Series:
|
|
"""
|
|
수수료 스트레스: 왕복 수수료 %p를 (mult-1)배 추가 차감.
|
|
|
|
Args:
|
|
series: forward_ret_pct.
|
|
mult: 수수료 배수 (2.0 = 2배).
|
|
|
|
Returns:
|
|
조정된 수익률 %.
|
|
"""
|
|
extra = TRADING_FEE_RATE * 2 * 100 * (mult - 1.0)
|
|
return series - extra
|
|
|
|
|
|
def walk_forward_by_month(outcomes: pd.DataFrame) -> list[dict[str, Any]]:
|
|
"""
|
|
규칙·월별 EV·PF 집계.
|
|
|
|
Args:
|
|
outcomes: fire_outcomes.
|
|
|
|
Returns:
|
|
월별 행 dict 리스트.
|
|
"""
|
|
if outcomes.empty:
|
|
return []
|
|
df = outcomes.copy()
|
|
df["ts"] = pd.to_datetime(df["dt"])
|
|
df["month"] = df["ts"].dt.to_period("M").astype(str)
|
|
rows: list[dict[str, Any]] = []
|
|
for (rid, month), grp in df.groupby(["rule_id", "month"]):
|
|
m = _rule_metrics(grp)
|
|
rows.append(
|
|
{
|
|
"rule_id": rid,
|
|
"side": grp["side"].iloc[0],
|
|
"month": month,
|
|
**m,
|
|
}
|
|
)
|
|
return rows
|
|
|
|
|
|
def walk_forward_summary(wf_rows: list[dict[str, Any]]) -> dict[str, Any]:
|
|
"""
|
|
규칙별 월별 EV 양수 비율 요약.
|
|
|
|
Args:
|
|
wf_rows: walk_forward_by_month 결과.
|
|
|
|
Returns:
|
|
rule_id → {positive_ratio, months, ...}.
|
|
"""
|
|
if not wf_rows:
|
|
return {}
|
|
df = pd.DataFrame(wf_rows)
|
|
out: dict[str, Any] = {}
|
|
for rid, grp in df.groupby("rule_id"):
|
|
n = len(grp)
|
|
pos = int((grp["ev_pct"] > 0).sum())
|
|
out[rid] = {
|
|
"months": n,
|
|
"positive_months": pos,
|
|
"positive_ratio": round(pos / n, 4) if n else 0.0,
|
|
"mean_ev_pct": round(float(grp["ev_pct"].mean()), 4),
|
|
}
|
|
return out
|
|
|
|
|
|
def simulate_live_order_cap(
|
|
outcomes: pd.DataFrame,
|
|
*,
|
|
rule_ids: set[str] | None = None,
|
|
holdout_only: bool = True,
|
|
) -> dict[str, Any]:
|
|
"""
|
|
GT 복리 배분·슬리피지 가정으로 체결 가능한 발화 집계 (일·금액 한도 없음).
|
|
|
|
Args:
|
|
outcomes: fire_outcomes (split 컬럼 있으면 holdout 필터 가능).
|
|
rule_ids: None이면 전 규칙, 지정 시 해당 rule만.
|
|
holdout_only: True면 split==holdout 만.
|
|
|
|
Returns:
|
|
규칙별·전체 요약.
|
|
"""
|
|
if outcomes.empty:
|
|
return {"rules": {}, "note": "발화 없음"}
|
|
|
|
df = outcomes.copy()
|
|
if holdout_only and "split" in df.columns:
|
|
df = df[df["split"] == "holdout"]
|
|
if rule_ids is not None:
|
|
df = df[df["rule_id"].isin(rule_ids)]
|
|
slip = LIVE_SLIPPAGE_PCT
|
|
|
|
trades = fires_to_trade_list(sort_fires_chronological(df), apply_dynamic_sizing=True)
|
|
executed_dts = {
|
|
t["dt"]
|
|
for t in trades
|
|
if t.get("action") == "sell" or float(t.get("amount_krw") or 0) > 0
|
|
}
|
|
if not executed_dts:
|
|
return {"rules": {}, "taken_count": 0, "total_count": int(len(df))}
|
|
|
|
taken = df[df["dt"].astype(str).isin(executed_dts)].copy()
|
|
taken["adj_ret_pct"] = taken["forward_ret_pct"] - slip
|
|
|
|
by_rule: dict[str, Any] = {}
|
|
for rid, grp in taken.groupby("rule_id"):
|
|
g = grp.copy()
|
|
g["forward_ret_pct"] = g["adj_ret_pct"]
|
|
by_rule[rid] = {
|
|
"taken_count": int(len(grp)),
|
|
"total_count": int((df["rule_id"] == rid).sum()),
|
|
"metrics": _rule_metrics(g),
|
|
}
|
|
|
|
return {
|
|
"assumptions": {
|
|
"slippage_pct": slip,
|
|
"sizing": "gt_model_compound_no_daily_cap",
|
|
},
|
|
"taken_count": int(len(taken)),
|
|
"total_count": int(len(df)),
|
|
"rules": by_rule,
|
|
"portfolio_adj_ev_pct": round(float(taken["adj_ret_pct"].mean()), 4),
|
|
}
|
|
|
|
|
|
def evaluate_go_no_go(
|
|
matched: dict[str, Any],
|
|
wf_summary: dict[str, Any],
|
|
fee_stress: dict[str, Any],
|
|
live_cap: dict[str, Any],
|
|
) -> dict[str, Any]:
|
|
"""
|
|
monitor_rules·holdout·walk-forward·수수료 스트레스 기준 Go/No-Go.
|
|
|
|
Args:
|
|
matched: matched_rules.json 내용.
|
|
wf_summary: walk_forward_summary.
|
|
fee_stress: 규칙별 fee 2x EV.
|
|
live_cap: simulate_live_order_cap.
|
|
|
|
Returns:
|
|
go, checks, monitor_rules 판정.
|
|
"""
|
|
rules = matched.get("monitor_rules") or matched.get("selected") or []
|
|
checks: list[dict[str, Any]] = []
|
|
all_go = True
|
|
|
|
for rule in rules:
|
|
rid = rule["rule_id"]
|
|
h = rule.get("metrics", {}).get("holdout", {})
|
|
ev_h = float(h.get("ev_pct", -999))
|
|
pf_h = float(h.get("profit_factor", 0))
|
|
wf = wf_summary.get(rid, {})
|
|
wf_ratio = float(wf.get("positive_ratio", 0))
|
|
wf_months = int(wf.get("months", 0))
|
|
stress_ev = fee_stress.get(rid, {}).get("ev_pct", -999)
|
|
|
|
c_holdout = ev_h >= SIM_GO_MIN_HOLDOUT_EV and pf_h >= SIM_GO_MIN_HOLDOUT_PF
|
|
c_wf = wf_months >= SIM_WALK_FORWARD_MIN_MONTHS and wf_ratio >= SIM_GO_WF_POSITIVE_RATIO
|
|
c_fee = stress_ev >= SIM_GO_MIN_HOLDOUT_EV
|
|
ok = c_holdout and c_wf and c_fee
|
|
if not ok:
|
|
all_go = False
|
|
checks.append(
|
|
{
|
|
"rule_id": rid,
|
|
"side": rule.get("side"),
|
|
"pass": ok,
|
|
"holdout_ev": ev_h,
|
|
"holdout_pf": pf_h,
|
|
"wf_positive_ratio": wf_ratio,
|
|
"fee_stress_ev": stress_ev,
|
|
}
|
|
)
|
|
|
|
return {
|
|
"go": all_go and len(checks) > 0,
|
|
"checks": checks,
|
|
"live_cap_taken_ratio": round(
|
|
live_cap.get("taken_count", 0) / max(live_cap.get("total_count", 1), 1),
|
|
4,
|
|
),
|
|
}
|
|
|
|
|
|
def portfolio_holdout_from_steps(
|
|
steps: list[dict[str, Any]],
|
|
holdout_start: pd.Timestamp,
|
|
*,
|
|
initial_if_empty: float = GT_INITIAL_CASH_KRW,
|
|
trade_count: int = 0,
|
|
note: str = "",
|
|
) -> dict[str, Any]:
|
|
"""
|
|
포트폴리오 step에서 holdout 구간 자산 증감.
|
|
|
|
Args:
|
|
steps: simulate_portfolio_steps 결과.
|
|
holdout_start: holdout 시작 시각.
|
|
initial_if_empty: step 없을 때 시작 자산.
|
|
trade_count: holdout 발화 수.
|
|
note: 설명.
|
|
|
|
Returns:
|
|
holdout pnl 요약 dict.
|
|
"""
|
|
if not steps:
|
|
return {"pnl_pct": 0.0, "note": "steps empty"}
|
|
assets = [(pd.to_datetime(s["dt"]), float(s["total_asset_krw"])) for s in steps]
|
|
pre = [a for d, a in assets if d < holdout_start]
|
|
in_h = [a for d, a in assets if d >= holdout_start]
|
|
asset_start = pre[-1] if pre else float(initial_if_empty)
|
|
asset_end = in_h[-1] if in_h else assets[-1][1]
|
|
ho_pnl_pct = (
|
|
(asset_end - asset_start) / asset_start * 100.0 if asset_start > 0 else 0.0
|
|
)
|
|
return {
|
|
"initial_asset_krw": round(asset_start, 0),
|
|
"final_asset_krw": round(asset_end, 0),
|
|
"pnl_krw": round(asset_end - asset_start, 0),
|
|
"pnl_pct": round(ho_pnl_pct, 2),
|
|
"trade_count": int(trade_count),
|
|
"note": note,
|
|
}
|
|
|
|
|
|
def evaluate_hybrid_sizing_go(
|
|
base_go: dict[str, Any],
|
|
hybrid_full: dict[str, Any],
|
|
hybrid_holdout: dict[str, Any],
|
|
hybrid_fee_stress: dict[str, Any],
|
|
) -> dict[str, Any]:
|
|
"""
|
|
hybrid DD tier 배분 승격 Go/No-Go (규칙 Go + holdout·MDD·수수료 스트레스).
|
|
|
|
Args:
|
|
base_go: monitor 규칙 evaluate_go_no_go 결과.
|
|
hybrid_full: 전기간 hybrid 포트폴리오 요약.
|
|
hybrid_holdout: holdout 구간 자산 증감.
|
|
hybrid_fee_stress: 수수료 스트레스 hybrid 포트폴리오.
|
|
|
|
Returns:
|
|
go, checks, primary_sizing 권장.
|
|
"""
|
|
from config import (
|
|
SIM_HYBRID_MAX_MDD_PCT,
|
|
SIM_HYBRID_MIN_HOLDOUT_PNL_PCT,
|
|
SIM_OPTION_C_TARGET_PNL_PCT,
|
|
SIM_PRIMARY_SIZING,
|
|
)
|
|
|
|
base_ok = bool(base_go.get("go"))
|
|
ho_pnl = float(hybrid_holdout.get("pnl_pct", -999))
|
|
full_pnl = float(hybrid_full.get("pnl_pct", 0))
|
|
mdd = float(hybrid_full.get("max_drawdown_pct", 999))
|
|
stress_pnl = float(hybrid_fee_stress.get("pnl_pct", -999))
|
|
|
|
c_base = base_ok
|
|
c_holdout = ho_pnl >= SIM_HYBRID_MIN_HOLDOUT_PNL_PCT
|
|
c_mdd = mdd <= SIM_HYBRID_MAX_MDD_PCT
|
|
c_fee = stress_pnl > 0.0
|
|
c_target = full_pnl >= SIM_OPTION_C_TARGET_PNL_PCT
|
|
|
|
all_go = c_base and c_holdout and c_mdd and c_fee
|
|
if SIM_PRIMARY_SIZING == "hybrid":
|
|
primary = "hybrid"
|
|
elif SIM_PRIMARY_SIZING == "causal_tier":
|
|
primary = "causal_tier"
|
|
else:
|
|
primary = "hybrid" if all_go else "causal_tier"
|
|
|
|
return {
|
|
"go": all_go,
|
|
"primary_sizing": primary,
|
|
"checks": [
|
|
{"name": "monitor_rules_go", "pass": c_base},
|
|
{"name": "hybrid_holdout_pnl", "pass": c_holdout, "value": ho_pnl},
|
|
{"name": "hybrid_max_mdd", "pass": c_mdd, "value": mdd},
|
|
{"name": "hybrid_fee_stress_pnl", "pass": c_fee, "value": stress_pnl},
|
|
{
|
|
"name": "option_c_target_300pct",
|
|
"pass": c_target,
|
|
"value": full_pnl,
|
|
"optional": True,
|
|
},
|
|
],
|
|
}
|
|
|
|
|
|
def simulate_hybrid_order_cap(
|
|
outcomes: pd.DataFrame,
|
|
ohlc_df: pd.DataFrame,
|
|
*,
|
|
rule_ids: set[str] | None = None,
|
|
holdout_only: bool = True,
|
|
fee_rate: float = TRADING_FEE_RATE,
|
|
dd_large_pct: float | None = None,
|
|
dd_medium_pct: float | None = None,
|
|
) -> dict[str, Any]:
|
|
"""
|
|
hybrid tier 복리 배분·슬리피지 가정 체결 가능 발화 집계.
|
|
|
|
Args:
|
|
outcomes: fire_outcomes.
|
|
ohlc_df: 3m OHLC (drawdown).
|
|
rule_ids: monitor rule_id 필터.
|
|
holdout_only: holdout만.
|
|
fee_rate: 수수료율.
|
|
|
|
Returns:
|
|
simulate_live_order_cap과 동일 구조.
|
|
"""
|
|
from deepcoin.ground_truth.causal_gt_hybrid import build_monitor_hybrid_sized_trades
|
|
|
|
if outcomes.empty:
|
|
return {"rules": {}, "note": "발화 없음"}
|
|
|
|
df = outcomes.copy()
|
|
if holdout_only and "split" in df.columns:
|
|
df = df[df["split"] == "holdout"]
|
|
if rule_ids is not None:
|
|
df = df[df["rule_id"].isin(rule_ids)]
|
|
slip = LIVE_SLIPPAGE_PCT
|
|
|
|
sized, _ = build_monitor_hybrid_sized_trades(
|
|
sort_fires_chronological(df),
|
|
ohlc_df,
|
|
enhanced=False,
|
|
fee_rate=fee_rate,
|
|
dd_large_pct=dd_large_pct,
|
|
dd_medium_pct=dd_medium_pct,
|
|
)
|
|
executed_dts = {
|
|
t["dt"]
|
|
for t in sized
|
|
if t.get("action") == "sell" or float(t.get("amount_krw") or 0) > 0
|
|
}
|
|
if not executed_dts:
|
|
return {"rules": {}, "taken_count": 0, "total_count": int(len(df))}
|
|
|
|
taken = df[df["dt"].astype(str).isin(executed_dts)].copy()
|
|
taken["adj_ret_pct"] = taken["forward_ret_pct"] - slip
|
|
|
|
by_rule: dict[str, Any] = {}
|
|
for rid, grp in taken.groupby("rule_id"):
|
|
g = grp.copy()
|
|
g["forward_ret_pct"] = g["adj_ret_pct"]
|
|
by_rule[rid] = {
|
|
"taken_count": int(len(grp)),
|
|
"total_count": int((df["rule_id"] == rid).sum()),
|
|
"metrics": _rule_metrics(g),
|
|
}
|
|
|
|
return {
|
|
"assumptions": {
|
|
"slippage_pct": slip,
|
|
"sizing": "hybrid_dd_tier_compound",
|
|
},
|
|
"taken_count": int(len(taken)),
|
|
"total_count": int(len(df)),
|
|
"rules": by_rule,
|
|
"portfolio_adj_ev_pct": round(float(taken["adj_ret_pct"].mean()), 4),
|
|
}
|
|
|
|
|
|
def build_simulation_report(
|
|
outcomes_path: Path | None = None,
|
|
matched_path: Path | None = None,
|
|
) -> dict[str, Any]:
|
|
"""
|
|
시뮬레이션 리포트 dict 생성.
|
|
|
|
Args:
|
|
outcomes_path: fire_outcomes.csv.
|
|
matched_path: matched_rules.json.
|
|
|
|
Returns:
|
|
simulation_report 전체 dict.
|
|
"""
|
|
op = outcomes_path or MATCHING_FIRE_OUTCOMES
|
|
mp = matched_path or MATCHING_MATCHED_RULES
|
|
if not op.is_file():
|
|
raise FileNotFoundError(f"fire_outcomes 없음: {op} — 04_match_rules.py 먼저 실행")
|
|
outcomes = pd.read_csv(op)
|
|
matched: dict[str, Any] = {}
|
|
if mp.is_file():
|
|
matched = json.loads(mp.read_text(encoding="utf-8"))
|
|
|
|
outcomes["split"] = _split_train_valid_holdout(outcomes)
|
|
wf_rows = walk_forward_by_month(outcomes)
|
|
wf_sum = walk_forward_summary(wf_rows)
|
|
|
|
fee_stress: dict[str, Any] = {}
|
|
for rid in outcomes["rule_id"].unique():
|
|
sub = outcomes[outcomes["rule_id"] == rid]
|
|
adj = _fee_adjust_ret(sub["forward_ret_pct"], SIM_FEE_STRESS_MULT)
|
|
fee_stress[rid] = _rule_metrics(
|
|
sub.assign(forward_ret_pct=adj)
|
|
)
|
|
|
|
monitor_ids = {r["rule_id"] for r in matched.get("monitor_rules", [])}
|
|
live_cap = simulate_live_order_cap(
|
|
outcomes, rule_ids=monitor_ids, holdout_only=True
|
|
)
|
|
go = evaluate_go_no_go(matched, wf_sum, fee_stress, live_cap)
|
|
|
|
portfolio_compare: dict[str, Any] = {}
|
|
gt_data = load_ground_truth(resolve_ground_truth_file()) or {}
|
|
gt_trades = gt_data.get("trades") or []
|
|
mark = (gt_data.get("summary") or {}).get("mark_price")
|
|
gt_chrono = order_trades_chronological(gt_trades) if gt_trades else []
|
|
|
|
from deepcoin.ground_truth.gt_signal_rules import gt_signal_rule_ids
|
|
from config import GT_SIGNAL_CAUSAL, SIM_CAUSAL_TIER
|
|
from deepcoin.matching.position_sizing import load_gt_allocation_analysis
|
|
|
|
gt_alloc_analysis = load_gt_allocation_analysis(gt_trades) if gt_trades else {}
|
|
|
|
if gt_chrono:
|
|
if not any(float(t.get("amount_krw") or 0) > 0 for t in gt_chrono):
|
|
from deepcoin.ground_truth.ground_truth import allocate_gt_order_amounts
|
|
|
|
allocate_gt_order_amounts(gt_chrono)
|
|
portfolio_compare["ground_truth_chrono"] = simulate_portfolio_summary(
|
|
gt_chrono,
|
|
last_price=float(mark) if mark else None,
|
|
use_amount_krw=True,
|
|
)
|
|
|
|
# 전기간 monitor 규칙 — GT_INITIAL_CASH_KRW에서 복리 (holdout만 X)
|
|
all_monitor = outcomes[outcomes["rule_id"].isin(monitor_ids)]
|
|
if not all_monitor.empty:
|
|
sim_trades_full = fires_to_trade_list(sort_fires_chronological(all_monitor))
|
|
portfolio_compare["sim_sized"] = simulate_sized_portfolio(
|
|
sim_trades_full,
|
|
last_price=float(mark) if mark else None,
|
|
)
|
|
portfolio_compare["sim_fixed_order"] = simulate_fixed_order_portfolio(
|
|
fires_to_trade_list(all_monitor, apply_dynamic_sizing=False),
|
|
last_price=float(mark) if mark else None,
|
|
)
|
|
|
|
# GT 모델 일반화 규칙 (ZigZag+BB 매수 / ZigZag 고점 매도)
|
|
gt_buy_rule = "gt_model_buy_zigzag_bb"
|
|
gt_sell_rule = "gt_model_sell_zigzag_peak"
|
|
gt_pair_ids = {gt_buy_rule, gt_sell_rule}
|
|
if gt_pair_ids.issubset(set(outcomes["rule_id"].unique())):
|
|
gt_pair_fires = outcomes[outcomes["rule_id"].isin(gt_pair_ids)]
|
|
gt_pair_trades = fires_to_trade_list(sort_fires_chronological(gt_pair_fires))
|
|
portfolio_compare["sim_gt_model"] = simulate_sized_portfolio(
|
|
gt_pair_trades,
|
|
last_price=float(mark) if mark else None,
|
|
)
|
|
|
|
# 인과 GT leg 엔진 (split_buy + peak_sell, 캘리브레이션 파라미터)
|
|
cg_df = None
|
|
try:
|
|
from config import CHART_LOOKBACK_DAYS, MATCH_PRIMARY_INTERVAL, SYMBOL
|
|
from deepcoin.data.mtf_bb import load_frames_from_db
|
|
from deepcoin.ground_truth.causal_gt_calibrate import load_causal_gt_params
|
|
from deepcoin.ground_truth.causal_gt_trades import simulate_causal_gt_portfolio
|
|
from deepcoin.ops.monitor import Monitor
|
|
|
|
cg_params = load_causal_gt_params()
|
|
mon_cg = Monitor(cooldown_file=None)
|
|
cg_frames = load_frames_from_db(mon_cg, SYMBOL, lookback_days=CHART_LOOKBACK_DAYS)
|
|
cg_df = cg_frames[MATCH_PRIMARY_INTERVAL]
|
|
portfolio_compare["sim_causal_gt"] = simulate_causal_gt_portfolio(
|
|
cg_df,
|
|
last_price=float(mark) if mark else None,
|
|
**cg_params,
|
|
)
|
|
# Phase 3: monitor buy + 인과 peak sell + drawdown tier
|
|
from deepcoin.ground_truth.causal_gt_hybrid import (
|
|
simulate_causal_gt_hybrid_portfolio,
|
|
simulate_monitor_tier_enhanced_portfolio,
|
|
)
|
|
from deepcoin.ground_truth.hybrid_dd_calibrate import load_hybrid_dd_params
|
|
|
|
dd_params = load_hybrid_dd_params()
|
|
|
|
buy_only = all_monitor[all_monitor["side"] == "buy"]
|
|
portfolio_compare["sim_causal_hybrid"] = simulate_causal_gt_hybrid_portfolio(
|
|
buy_only,
|
|
cg_df,
|
|
monitor_fires=all_monitor,
|
|
last_price=float(mark) if mark else None,
|
|
cg_params=cg_params,
|
|
dd_large_pct=dd_params.get("dd_large_pct"),
|
|
dd_medium_pct=dd_params.get("dd_medium_pct"),
|
|
)
|
|
portfolio_compare["hybrid_dd_params"] = dd_params
|
|
portfolio_compare["sim_tier_enhanced"] = simulate_monitor_tier_enhanced_portfolio(
|
|
all_monitor,
|
|
cg_df,
|
|
last_price=float(mark) if mark else None,
|
|
)
|
|
except Exception as exc:
|
|
portfolio_compare["sim_causal_gt"] = {
|
|
"pnl_pct": 0.0,
|
|
"note": f"causal_gt sim skipped: {exc}",
|
|
}
|
|
portfolio_compare["sim_causal_hybrid"] = {
|
|
"pnl_pct": 0.0,
|
|
"note": f"causal_hybrid sim skipped: {exc}",
|
|
}
|
|
portfolio_compare["sim_tier_enhanced"] = {
|
|
"pnl_pct": 0.0,
|
|
"note": f"tier_enhanced sim skipped: {exc}",
|
|
}
|
|
|
|
holdout = outcomes[
|
|
outcomes["rule_id"].isin(monitor_ids) & (outcomes["split"] == "holdout")
|
|
]
|
|
if not holdout.empty and not all_monitor.empty:
|
|
full_trades = fires_to_trade_list(sort_fires_chronological(all_monitor))
|
|
if full_trades:
|
|
from deepcoin.ground_truth.gt_allocation import simulate_portfolio_steps
|
|
|
|
steps = simulate_portfolio_steps(full_trades, use_amount_krw=True)
|
|
if steps:
|
|
outcomes_ts = outcomes.copy()
|
|
outcomes_ts["ts"] = pd.to_datetime(outcomes_ts["dt"])
|
|
h0 = outcomes_ts["ts"].quantile(1.0 - MATCH_HOLDOUT_RATIO)
|
|
portfolio_compare["sim_sized_holdout"] = portfolio_holdout_from_steps(
|
|
steps,
|
|
h0,
|
|
trade_count=int(len(holdout)),
|
|
note="전기간 복리(causal tier) 후 holdout 구간 자산 증감",
|
|
)
|
|
|
|
go_hybrid: dict[str, Any] = {"go": False, "note": "hybrid sim unavailable"}
|
|
go_option_c_phase2: dict[str, Any] = {"go": False, "note": "phase2 unavailable"}
|
|
if (
|
|
cg_df is not None
|
|
and not all_monitor.empty
|
|
and portfolio_compare.get("sim_causal_hybrid", {}).get("sizing_mode")
|
|
):
|
|
from deepcoin.ground_truth.causal_gt_hybrid import build_monitor_hybrid_sized_trades
|
|
from deepcoin.ground_truth.gt_allocation import simulate_portfolio_steps
|
|
from deepcoin.ground_truth.hybrid_dd_calibrate import load_hybrid_dd_params
|
|
from deepcoin.matching.option_c_phase2 import (
|
|
evaluate_option_c_phase2_go,
|
|
simulate_hybrid_slippage_stress,
|
|
walk_forward_portfolio_by_month,
|
|
walk_forward_portfolio_summary,
|
|
)
|
|
|
|
dd_params = portfolio_compare.get("hybrid_dd_params") or load_hybrid_dd_params()
|
|
dd_large = dd_params.get("dd_large_pct")
|
|
dd_medium = dd_params.get("dd_medium_pct")
|
|
|
|
hybrid_full = portfolio_compare["sim_causal_hybrid"]
|
|
sized_h, _ = build_monitor_hybrid_sized_trades(
|
|
sort_fires_chronological(all_monitor),
|
|
cg_df,
|
|
enhanced=False,
|
|
dd_large_pct=dd_large,
|
|
dd_medium_pct=dd_medium,
|
|
)
|
|
steps_h = simulate_portfolio_steps(sized_h, use_amount_krw=True)
|
|
if steps_h and not holdout.empty:
|
|
outcomes_ts = outcomes.copy()
|
|
outcomes_ts["ts"] = pd.to_datetime(outcomes_ts["dt"])
|
|
h0 = outcomes_ts["ts"].quantile(1.0 - MATCH_HOLDOUT_RATIO)
|
|
portfolio_compare["sim_hybrid_holdout"] = portfolio_holdout_from_steps(
|
|
steps_h,
|
|
h0,
|
|
trade_count=int(len(holdout)),
|
|
note="전기간 복리(hybrid DD tier) 후 holdout 구간 자산 증감",
|
|
)
|
|
|
|
stress_fee = TRADING_FEE_RATE * SIM_FEE_STRESS_MULT
|
|
sized_stress, _ = build_monitor_hybrid_sized_trades(
|
|
sort_fires_chronological(all_monitor),
|
|
cg_df,
|
|
enhanced=False,
|
|
fee_rate=stress_fee,
|
|
dd_large_pct=dd_large,
|
|
dd_medium_pct=dd_medium,
|
|
)
|
|
portfolio_compare["sim_hybrid_fee_stress"] = simulate_portfolio_summary(
|
|
sized_stress,
|
|
fee_rate=stress_fee,
|
|
last_price=float(mark) if mark else None,
|
|
use_amount_krw=True,
|
|
)
|
|
|
|
portfolio_compare["sim_hybrid_slippage_stress"] = simulate_hybrid_slippage_stress(
|
|
sized_h,
|
|
last_price=float(mark) if mark else None,
|
|
fee_rate=TRADING_FEE_RATE,
|
|
)
|
|
wf_rows = walk_forward_portfolio_by_month(steps_h)
|
|
wf_port = walk_forward_portfolio_summary(wf_rows)
|
|
portfolio_compare["hybrid_portfolio_walk_forward"] = wf_rows
|
|
portfolio_compare["hybrid_portfolio_wf_summary"] = wf_port
|
|
|
|
gt_pnl_for_phase2 = float(
|
|
(portfolio_compare.get("ground_truth_chrono") or {}).get("pnl_pct", 0)
|
|
)
|
|
go_hybrid = evaluate_hybrid_sizing_go(
|
|
go,
|
|
hybrid_full,
|
|
portfolio_compare.get("sim_hybrid_holdout") or {},
|
|
portfolio_compare.get("sim_hybrid_fee_stress") or {},
|
|
)
|
|
go_option_c_phase2 = evaluate_option_c_phase2_go(
|
|
go_hybrid,
|
|
hybrid_full,
|
|
portfolio_compare.get("sim_hybrid_holdout") or {},
|
|
portfolio_compare.get("sim_hybrid_fee_stress") or {},
|
|
portfolio_compare.get("sim_hybrid_slippage_stress") or {},
|
|
wf_port,
|
|
gt_pnl_for_phase2,
|
|
)
|
|
|
|
primary = go_hybrid.get("primary_sizing", "causal_tier")
|
|
portfolio_compare["primary_sizing"] = primary
|
|
if primary == "hybrid":
|
|
portfolio_compare["sim_primary"] = {
|
|
**hybrid_full,
|
|
"sizing_mode": "primary_hybrid_dd_tier",
|
|
"sizing_note": (
|
|
"권장: monitor + past-leg·drawdown tier (검증 통과, 미래 미사용)"
|
|
),
|
|
}
|
|
live_cap = simulate_hybrid_order_cap(
|
|
outcomes,
|
|
cg_df,
|
|
rule_ids=monitor_ids,
|
|
holdout_only=True,
|
|
dd_large_pct=dd_large,
|
|
dd_medium_pct=dd_medium,
|
|
)
|
|
else:
|
|
portfolio_compare["sim_primary"] = portfolio_compare.get("sim_sized") or {}
|
|
|
|
if portfolio_compare.get("sim_sized") and portfolio_compare.get("ground_truth_chrono"):
|
|
gt_pnl = float(portfolio_compare["ground_truth_chrono"].get("pnl_pct", 0))
|
|
sim_pnl = float(portfolio_compare["sim_sized"].get("pnl_pct", 0))
|
|
portfolio_compare["gt_capture_ratio"] = round(
|
|
sim_pnl / gt_pnl if abs(gt_pnl) > 1e-6 else 0.0,
|
|
4,
|
|
)
|
|
portfolio_compare["gt_pnl_pct"] = gt_pnl
|
|
portfolio_compare["sim_sized_pnl_pct"] = sim_pnl
|
|
if portfolio_compare.get("sim_gt_model"):
|
|
gtp = float(portfolio_compare["sim_gt_model"].get("pnl_pct", 0))
|
|
portfolio_compare["gt_model_capture_ratio"] = round(
|
|
gtp / gt_pnl if abs(gt_pnl) > 1e-6 else 0.0,
|
|
4,
|
|
)
|
|
if portfolio_compare.get("sim_causal_gt"):
|
|
cgp = float(portfolio_compare["sim_causal_gt"].get("pnl_pct", 0))
|
|
portfolio_compare["causal_gt_capture_ratio"] = round(
|
|
cgp / gt_pnl if abs(gt_pnl) > 1e-6 else 0.0,
|
|
4,
|
|
)
|
|
portfolio_compare["sim_causal_gt_pnl_pct"] = cgp
|
|
if portfolio_compare.get("sim_causal_hybrid"):
|
|
chp = float(portfolio_compare["sim_causal_hybrid"].get("pnl_pct", 0))
|
|
portfolio_compare["causal_hybrid_capture_ratio"] = round(
|
|
chp / gt_pnl if abs(gt_pnl) > 1e-6 else 0.0,
|
|
4,
|
|
)
|
|
portfolio_compare["sim_causal_hybrid_pnl_pct"] = chp
|
|
if portfolio_compare.get("sim_tier_enhanced"):
|
|
tep = float(portfolio_compare["sim_tier_enhanced"].get("pnl_pct", 0))
|
|
portfolio_compare["tier_enhanced_capture_ratio"] = round(
|
|
tep / gt_pnl if abs(gt_pnl) > 1e-6 else 0.0,
|
|
4,
|
|
)
|
|
portfolio_compare["sim_tier_enhanced_pnl_pct"] = tep
|
|
|
|
portfolio_compare["causal_gt_params"] = {}
|
|
try:
|
|
from deepcoin.ground_truth.causal_gt_calibrate import load_causal_gt_params
|
|
|
|
portfolio_compare["causal_gt_params"] = load_causal_gt_params()
|
|
except Exception:
|
|
pass
|
|
|
|
portfolio_compare["gt_allocation_analysis"] = gt_alloc_analysis
|
|
portfolio_compare["causal_mode"] = {
|
|
"gt_signal_causal": GT_SIGNAL_CAUSAL,
|
|
"sim_causal_tier": SIM_CAUSAL_TIER,
|
|
"note": "인과적: t 시점까지 데이터만 사용 (운영 정합)",
|
|
}
|
|
|
|
gt_portfolio: dict[str, Any] = {}
|
|
if ANALYSIS_GT_CALIBRATION_JSON.is_file():
|
|
cal = json.loads(ANALYSIS_GT_CALIBRATION_JSON.read_text(encoding="utf-8"))
|
|
gt_portfolio = cal.get("final", {})
|
|
else:
|
|
from deepcoin.matching.gt_asset_calibration import (
|
|
portfolio_asset_ratio,
|
|
)
|
|
|
|
gt_data_cal = load_ground_truth(resolve_ground_truth_file()) or {}
|
|
trades = gt_data_cal.get("trades") or []
|
|
mark_cal = (gt_data_cal.get("summary") or {}).get("mark_price")
|
|
if trades:
|
|
gt_portfolio = {
|
|
"portfolio": portfolio_asset_ratio(trades, set(), mark_cal),
|
|
"note": "캘리브레이션 미실행 — scripts/04_calibrate_gt_assets.py",
|
|
}
|
|
|
|
summaries = matched.get("all_rule_summaries") or matched.get("monitor_rules") or []
|
|
leg_weight_check = summarize_leg_weights(gt_trades) if gt_trades else {}
|
|
invalid_legs = [lid for lid, info in leg_weight_check.items() if not info.get("valid", True)]
|
|
return {
|
|
"label_mode": matched.get("label_mode"),
|
|
"train_ratio": MATCH_TRAIN_RATIO,
|
|
"holdout_ratio": MATCH_HOLDOUT_RATIO,
|
|
"outcomes_rows": int(len(outcomes)),
|
|
"walk_forward": wf_rows,
|
|
"walk_forward_summary": wf_sum,
|
|
"fee_stress_mult": SIM_FEE_STRESS_MULT,
|
|
"fee_stress_by_rule": fee_stress,
|
|
"live_order_cap_sim": live_cap,
|
|
"go_no_go": go,
|
|
"go_no_go_hybrid": go_hybrid,
|
|
"go_no_go_option_c_phase2": go_option_c_phase2,
|
|
"portfolio_compare": portfolio_compare,
|
|
"gt_model": gt_data.get("model") or model_to_dict(default_model()),
|
|
"gt_weight_policy": weight_policy_summary(default_model()),
|
|
"gt_leg_weight_validation": {
|
|
"legs": leg_weight_check,
|
|
"invalid_leg_ids": invalid_legs,
|
|
"all_valid": len(invalid_legs) == 0,
|
|
},
|
|
"monitor_rules": matched.get("monitor_rules", []),
|
|
"gt_portfolio_calibration": gt_portfolio,
|
|
"criteria": {
|
|
"min_holdout_ev": SIM_GO_MIN_HOLDOUT_EV,
|
|
"min_holdout_pf": SIM_GO_MIN_HOLDOUT_PF,
|
|
"wf_positive_ratio": SIM_GO_WF_POSITIVE_RATIO,
|
|
"wf_min_months": SIM_WALK_FORWARD_MIN_MONTHS,
|
|
"hybrid_min_holdout_pnl_pct": SIM_HYBRID_MIN_HOLDOUT_PNL_PCT,
|
|
"hybrid_max_mdd_pct": SIM_HYBRID_MAX_MDD_PCT,
|
|
"option_c_target_pnl_pct": SIM_OPTION_C_TARGET_PNL_PCT,
|
|
"option_c_phase2_target_pnl_pct": SIM_OPTION_C_PHASE2_TARGET_PNL_PCT,
|
|
"option_c_phase2_fee_stress_ratio": SIM_OPTION_C_PHASE2_FEE_STRESS_RATIO,
|
|
"option_c_min_gt_capture": SIM_OPTION_C_MIN_GT_CAPTURE,
|
|
},
|
|
}
|
|
|
|
|
|
def write_simulation_html(report: dict[str, Any], out_path: Path) -> Path:
|
|
"""
|
|
simulation_report.html 저장 (ground_truth 차트 동일 스타일).
|
|
|
|
Args:
|
|
report: build_simulation_report 결과.
|
|
out_path: HTML 경로.
|
|
|
|
Returns:
|
|
out_path.
|
|
"""
|
|
from deepcoin.matching.simulation_html import write_simulation_report_html
|
|
|
|
return write_simulation_report_html(report, out_path)
|
|
|
|
|
|
def run_simulation_report(
|
|
outcomes_path: Path | None = None,
|
|
matched_path: Path | None = None,
|
|
) -> dict[str, Any]:
|
|
"""
|
|
시뮬 리포트 생성·저장·요약 출력.
|
|
|
|
Args:
|
|
outcomes_path: fire_outcomes.csv.
|
|
matched_path: matched_rules.json.
|
|
|
|
Returns:
|
|
report dict.
|
|
"""
|
|
report = build_simulation_report(outcomes_path, matched_path)
|
|
MATCHING_SIMULATION_JSON.parent.mkdir(parents=True, exist_ok=True)
|
|
MATCHING_SIMULATION_JSON.write_text(
|
|
json.dumps(report, ensure_ascii=False, indent=2),
|
|
encoding="utf-8",
|
|
)
|
|
write_simulation_html(report, MATCHING_SIMULATION_HTML)
|
|
go = report["go_no_go"]["go"]
|
|
go_h = report.get("go_no_go_hybrid") or {}
|
|
pc_early = report.get("portfolio_compare") or {}
|
|
print(f"[시뮬] 저장: {MATCHING_SIMULATION_JSON}")
|
|
print(f"[시뮬] 저장: {MATCHING_SIMULATION_HTML}")
|
|
print(f"[시뮬] Go/No-Go (규칙): {'GO' if go else 'NO-GO'}")
|
|
print(
|
|
f"[시뮬] Go/No-Go (hybrid tier): {'GO' if go_h.get('go') else 'NO-GO'} "
|
|
f"· primary={pc_early.get('primary_sizing', '-')}"
|
|
)
|
|
for c in go_h.get("checks", []):
|
|
mark = "OK" if c.get("pass") else "NG"
|
|
opt = " (optional)" if c.get("optional") else ""
|
|
print(f" [hybrid {mark}] {c.get('name')}: {c.get('value', '-')}{opt}")
|
|
go_p2 = report.get("go_no_go_option_c_phase2") or {}
|
|
print(
|
|
f"[시뮬] Option C 2차(+1000%): {'GO' if go_p2.get('go') else 'NO-GO'}"
|
|
)
|
|
for c in go_p2.get("checks", []):
|
|
mark = "OK" if c.get("pass") else "NG"
|
|
print(f" [phase2 {mark}] {c.get('name')}: {c.get('value', '-')}")
|
|
for c in report["go_no_go"].get("checks", []):
|
|
mark = "OK" if c["pass"] else "NG"
|
|
print(
|
|
f" [{mark}] {c['rule_id']}: holdout EV={c['holdout_ev']} "
|
|
f"WF+={c['wf_positive_ratio']} fee2x EV={c['fee_stress_ev']}"
|
|
)
|
|
cal = report.get("gt_portfolio_calibration") or {}
|
|
port = cal.get("portfolio") or {}
|
|
pc = report.get("portfolio_compare") or {}
|
|
if pc.get("gt_capture_ratio") is not None:
|
|
print(
|
|
f"[시뮬] GT 대비 sim_sized(전기간 복리): {pc.get('sim_sized_pnl_pct')}% "
|
|
f"/ GT {pc.get('gt_pnl_pct')}% "
|
|
f"(capture={pc.get('gt_capture_ratio'):.2%})"
|
|
)
|
|
if pc.get("gt_model_capture_ratio") is not None:
|
|
print(
|
|
f"[시뮬] GT 대비 sim_gt_model: "
|
|
f"{pc.get('sim_gt_model', {}).get('pnl_pct')}% "
|
|
f"(capture={pc.get('gt_model_capture_ratio'):.2%})"
|
|
)
|
|
if pc.get("sim_causal_gt_pnl_pct") is not None:
|
|
scg = pc.get("sim_causal_gt") or {}
|
|
print(
|
|
f"[시뮬] GT 대비 sim_causal_gt(인과 leg): "
|
|
f"{pc.get('sim_causal_gt_pnl_pct')}% "
|
|
f"(capture={pc.get('causal_gt_capture_ratio', 0):.2%}, "
|
|
f"legs={scg.get('leg_count', '-')}, trades={scg.get('trade_count', '-')})"
|
|
)
|
|
if pc.get("sim_causal_hybrid_pnl_pct") is not None:
|
|
sch = pc.get("sim_causal_hybrid") or {}
|
|
print(
|
|
f"[시뮬] GT 대비 sim_causal_hybrid(monitor+DD tier): "
|
|
f"{pc.get('sim_causal_hybrid_pnl_pct')}% "
|
|
f"(capture={pc.get('causal_hybrid_capture_ratio', 0):.2%}, "
|
|
f"MDD={sch.get('max_drawdown_pct', '-')}%)"
|
|
)
|
|
if pc.get("sim_primary"):
|
|
sp = pc["sim_primary"]
|
|
print(
|
|
f"[시뮬] 권장 primary ({pc.get('primary_sizing')}): "
|
|
f"{sp.get('pnl_pct')}% · MDD={sp.get('max_drawdown_pct', '-')}%"
|
|
)
|
|
ho_h = pc.get("sim_hybrid_holdout") or {}
|
|
if ho_h.get("pnl_pct") is not None:
|
|
print(
|
|
f"[시뮬] hybrid holdout: {ho_h.get('pnl_pct')}% "
|
|
f"({ho_h.get('initial_asset_krw')}→{ho_h.get('final_asset_krw')})"
|
|
)
|
|
if pc.get("sim_tier_enhanced_pnl_pct") is not None:
|
|
ste = pc.get("sim_tier_enhanced") or {}
|
|
ast = ste.get("alloc_stats") or {}
|
|
print(
|
|
f"[시뮬] GT 대비 sim_tier_enhanced(conviction tier): "
|
|
f"{pc.get('sim_tier_enhanced_pnl_pct')}% "
|
|
f"(capture={pc.get('tier_enhanced_capture_ratio', 0):.2%}, "
|
|
f"large_buys={ast.get('large_tier_buy_count', '-')}, "
|
|
f"avg_buy={ast.get('buy_amount_avg_krw', '-')})"
|
|
)
|
|
if pc.get("sim_sized", {}).get("max_drawdown_pct") is not None:
|
|
print(
|
|
f"[시뮬] sim_sized MDD: {pc['sim_sized']['max_drawdown_pct']}% "
|
|
f"(GT MDD: {pc.get('ground_truth_chrono', {}).get('max_drawdown_pct')}%)"
|
|
)
|
|
if port.get("asset_ratio") is not None:
|
|
met = cal.get("targets_met", port.get("target_met_90"))
|
|
print(
|
|
f"[시뮬] GT 총자산 대비 leg subset 비율: {port['asset_ratio']:.2%} "
|
|
f"({port.get('legs_covered')}/{port.get('legs_total')} leg) "
|
|
f"목표90%={'달성' if met else '미달'}"
|
|
)
|
|
return report
|