feat: instrument model
This commit is contained in:
OpenSquared
@@ -40,6 +40,10 @@ class WhatIfBody(BaseModel):
|
||||
start_date: Optional[str] = None
|
||||
|
||||
|
||||
class NodeConfigBody(BaseModel):
|
||||
macro_key: Optional[str] = None # "" to clear, None = no-op
|
||||
|
||||
|
||||
class CalibrateBody(BaseModel):
|
||||
ref_date: Optional[str] = None
|
||||
|
||||
@@ -535,6 +539,128 @@ def calibrate_intercept(
|
||||
conn.close()
|
||||
|
||||
|
||||
@router.patch("/{instrument}/nodes/{node_id}")
|
||||
def update_node_config(
|
||||
instrument: str,
|
||||
node_id: str,
|
||||
body: NodeConfigBody,
|
||||
) -> Dict[str, Any]:
|
||||
"""Met à jour la configuration d'un nœud (macro_key) dans le graph_json persisté."""
|
||||
import json as _json
|
||||
from services.database import get_conn
|
||||
conn = get_conn()
|
||||
try:
|
||||
inst = instrument.upper()
|
||||
row = conn.execute(
|
||||
"SELECT graph_json FROM instrument_models WHERE instrument=?", (inst,)
|
||||
).fetchone()
|
||||
if not row:
|
||||
raise HTTPException(status_code=404, detail=f"Instrument {inst} introuvable")
|
||||
|
||||
graph_def = _json.loads(row["graph_json"])
|
||||
found = False
|
||||
for node in graph_def.get("nodes", []):
|
||||
if node["id"] == node_id:
|
||||
if body.macro_key is not None:
|
||||
if body.macro_key == "":
|
||||
node.pop("macro_key", None) # clear
|
||||
else:
|
||||
node["macro_key"] = body.macro_key
|
||||
found = True
|
||||
break
|
||||
|
||||
if not found:
|
||||
raise HTTPException(status_code=404, detail=f"Nœud {node_id} introuvable")
|
||||
|
||||
conn.execute(
|
||||
"UPDATE instrument_models SET graph_json=?, updated_at=datetime('now') WHERE instrument=?",
|
||||
(_json.dumps(graph_def), inst)
|
||||
)
|
||||
conn.commit()
|
||||
return {"ok": True, "node_id": node_id, "macro_key": body.macro_key}
|
||||
finally:
|
||||
conn.close()
|
||||
|
||||
|
||||
@router.get("/{instrument}/macro-guidance")
|
||||
def get_macro_guidance(instrument: str) -> List[Dict[str, Any]]:
|
||||
"""
|
||||
Retourne l'état courant et le prochain forecast pour chaque nœud input_manual
|
||||
avec un macro_key configuré.
|
||||
"""
|
||||
import json as _json
|
||||
from services.database import get_conn
|
||||
from services.instrument_models import build_macro_node_timeline, FF_MACRO_KEYS, _parse_ff_num
|
||||
from datetime import datetime, timedelta, date as date_type
|
||||
conn = get_conn()
|
||||
try:
|
||||
inst = instrument.upper()
|
||||
row = conn.execute(
|
||||
"SELECT graph_json FROM instrument_models WHERE instrument=?", (inst,)
|
||||
).fetchone()
|
||||
if not row:
|
||||
return []
|
||||
|
||||
graph_def = _json.loads(row["graph_json"])
|
||||
today = datetime.utcnow().date()
|
||||
result = []
|
||||
|
||||
for node in graph_def.get("nodes", []):
|
||||
if node.get("node_type") != "input_manual":
|
||||
continue
|
||||
macro_key = node.get("macro_key")
|
||||
if not macro_key:
|
||||
continue
|
||||
|
||||
meta = FF_MACRO_KEYS.get(macro_key, {})
|
||||
currency = meta.get("currency", "")
|
||||
patterns = meta.get("names", [])
|
||||
|
||||
# Current interpolated value
|
||||
date_from = today - timedelta(days=90)
|
||||
date_to = today + timedelta(days=180)
|
||||
tl = build_macro_node_timeline(conn, macro_key, date_from, date_to)
|
||||
current_v = tl.get(str(today))
|
||||
|
||||
# Next scheduled event from ff_calendar
|
||||
next_event = None
|
||||
if currency and patterns:
|
||||
try:
|
||||
ff_rows = conn.execute(
|
||||
"""SELECT event_date, event_name, forecast_value, previous_value
|
||||
FROM ff_calendar
|
||||
WHERE currency=? AND event_date > ?
|
||||
ORDER BY event_date ASC LIMIT 20""",
|
||||
(currency, str(today))
|
||||
).fetchall()
|
||||
for r in ff_rows:
|
||||
if any(p in r["event_name"].lower() for p in patterns):
|
||||
ev_date = date_type.fromisoformat(r["event_date"])
|
||||
forecast_v = _parse_ff_num(r.get("forecast_value") or r.get("previous_value"))
|
||||
next_event = {
|
||||
"date": r["event_date"],
|
||||
"name": r["event_name"],
|
||||
"forecast": forecast_v,
|
||||
"days_until": (ev_date - today).days,
|
||||
}
|
||||
break
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
result.append({
|
||||
"node_id": node["id"],
|
||||
"node_label": node.get("label", node["id"]),
|
||||
"macro_key": macro_key,
|
||||
"unit": node.get("unit", ""),
|
||||
"current_value": round(current_v, 4) if current_v is not None else None,
|
||||
"next_event": next_event,
|
||||
})
|
||||
|
||||
return result
|
||||
finally:
|
||||
conn.close()
|
||||
|
||||
|
||||
@router.get("/{instrument}")
|
||||
def get_instrument_model(
|
||||
instrument: str,
|
||||
|
||||
@@ -14,6 +14,12 @@ Nouveautés Phase 2 :
|
||||
- REGIME_WEIGHTS : multiplicateurs par couche selon 6 régimes de marché
|
||||
- _apply_regime_weights() : réécrit la formule output avec les poids du régime courant
|
||||
- simulate_timeline() inclut le régime du jour
|
||||
|
||||
Phase macro-guidance :
|
||||
- FF_MACRO_KEYS : mapping macro_key → {currency, event name patterns}
|
||||
- build_macro_node_timeline() : reconstruit une série temporelle journalière depuis ff_calendar
|
||||
- simulate_timeline() utilise des overrides time-varying pour les noeuds avec macro_key
|
||||
- structural_pips(t) devient une courbe guidée par les fondamentaux
|
||||
"""
|
||||
import json
|
||||
import math
|
||||
@@ -21,6 +27,173 @@ from datetime import datetime, timedelta, date as date_type
|
||||
from typing import Optional
|
||||
|
||||
|
||||
# ── Macro key mapping — ff_calendar event names per fundamental variable ───────
|
||||
# Each macro_key maps to a currency and a list of lowercased event name patterns.
|
||||
# The currency acts as a primary filter before pattern matching.
|
||||
FF_MACRO_KEYS: dict[str, dict] = {
|
||||
"fed_rate": {"currency": "USD", "label": "Taux Fed", "unit": "%",
|
||||
"names": ["interest rate decision", "federal funds rate", "fed rate"]},
|
||||
"ecb_rate": {"currency": "EUR", "label": "Taux BCE", "unit": "%",
|
||||
"names": ["interest rate decision", "deposit facility rate", "refinancing rate", "ecb rate"]},
|
||||
"boe_rate": {"currency": "GBP", "label": "Taux BoE", "unit": "%",
|
||||
"names": ["interest rate decision", "official bank rate", "boe rate"]},
|
||||
"boj_rate": {"currency": "JPY", "label": "Taux BoJ", "unit": "%",
|
||||
"names": ["interest rate decision", "boj rate", "policy rate"]},
|
||||
"us_cpi": {"currency": "USD", "label": "CPI US MoM", "unit": "%",
|
||||
"names": ["cpi m/m", "core cpi m/m", "inflation rate mom"]},
|
||||
"us_cpi_yoy": {"currency": "USD", "label": "CPI US YoY", "unit": "%",
|
||||
"names": ["cpi y/y", "core cpi y/y", "inflation rate yoy"]},
|
||||
"eu_cpi_yoy": {"currency": "EUR", "label": "HICP Eurozone YoY", "unit": "%",
|
||||
"names": ["inflation rate yoy", "hicp", "cpi y/y"]},
|
||||
"us_nfp": {"currency": "USD", "label": "NFP US", "unit": "K",
|
||||
"names": ["non-farm employment change", "nfp", "non farm payrolls"]},
|
||||
"us_pmi": {"currency": "USD", "label": "PMI US", "unit": "pts",
|
||||
"names": ["ism manufacturing pmi", "ism services pmi", "s&p global manufacturing"]},
|
||||
"eu_pmi": {"currency": "EUR", "label": "PMI Eurozone", "unit": "pts",
|
||||
"names": ["manufacturing pmi", "services pmi", "composite pmi"]},
|
||||
"us_gdp": {"currency": "USD", "label": "GDP US QoQ", "unit": "%",
|
||||
"names": ["gdp growth rate qoq", "gdp q/q", "gdp qoq"]},
|
||||
"eu_gdp": {"currency": "EUR", "label": "GDP Eurozone", "unit": "%",
|
||||
"names": ["gdp growth rate qoq", "gdp growth rate yoy"]},
|
||||
"us_unemployment": {"currency": "USD", "label": "Chômage US", "unit": "%",
|
||||
"names": ["unemployment rate"]},
|
||||
"eu_unemployment": {"currency": "EUR", "label": "Chômage Eurozone", "unit": "%",
|
||||
"names": ["unemployment rate"]},
|
||||
"us_retail_sales": {"currency": "USD", "label": "Ventes détail US", "unit": "%",
|
||||
"names": ["retail sales m/m", "retail sales mom", "core retail sales"]},
|
||||
}
|
||||
|
||||
|
||||
def _parse_ff_num(s: Optional[str]) -> Optional[float]:
|
||||
"""Parse une valeur ff_calendar (ex: '4.50%', '2.1K', '102.3') → float."""
|
||||
if not s:
|
||||
return None
|
||||
t = str(s).strip().upper()
|
||||
try:
|
||||
if t.endswith('K'): return float(t[:-1]) * 1_000
|
||||
if t.endswith('M'): return float(t[:-1]) * 1_000_000
|
||||
if t.endswith('B'): return float(t[:-1]) * 1_000_000_000
|
||||
return float(t.replace('%', '').replace(',', ''))
|
||||
except Exception:
|
||||
return None
|
||||
|
||||
|
||||
def build_macro_node_timeline(
|
||||
conn, macro_key: str, date_from: date_type, date_to: date_type
|
||||
) -> dict[str, float]:
|
||||
"""
|
||||
Reconstruit une série temporelle journalière {date_str: value} pour un macro_key.
|
||||
|
||||
Algorithme :
|
||||
1. Requête ff_calendar sur la monnaie + patterns du macro_key (±90j de marge)
|
||||
2. Extrait les valeurs connues : actual_value pour les dates passées,
|
||||
forecast_value (ou previous si absent) pour les dates futures
|
||||
3. Interpolation linéaire entre les points connus → courbe daily lisse
|
||||
4. Avant le premier point connu : valeur du premier point (extrapolation plate)
|
||||
5. Après le dernier point connu : valeur du dernier point (extrapolation plate)
|
||||
"""
|
||||
meta = FF_MACRO_KEYS.get(macro_key)
|
||||
if not meta:
|
||||
return {}
|
||||
|
||||
currency = meta["currency"]
|
||||
patterns = meta["names"]
|
||||
today = date_type.today()
|
||||
|
||||
# Wide window: look back up to 2 years to capture last known rate decision
|
||||
# (rate decisions can be 6+ weeks apart; CSV data may lag by months)
|
||||
q_from = str(date_from - timedelta(days=730))
|
||||
q_to = str(date_to + timedelta(days=180))
|
||||
|
||||
try:
|
||||
rows = conn.execute(
|
||||
"""SELECT event_date, event_name, actual_value, forecast_value, previous_value
|
||||
FROM ff_calendar
|
||||
WHERE currency=? AND event_date>=? AND event_date<=?
|
||||
ORDER BY event_date ASC""",
|
||||
(currency, q_from, q_to)
|
||||
).fetchall()
|
||||
except Exception:
|
||||
return {}
|
||||
|
||||
# Filter by name pattern
|
||||
matched = [
|
||||
dict(r) for r in rows
|
||||
if any(p in r["event_name"].lower() for p in patterns)
|
||||
]
|
||||
if not matched:
|
||||
return {}
|
||||
|
||||
# Deduplicate by date (keep first match per date — most specific pattern wins)
|
||||
seen: set[str] = set()
|
||||
deduped = []
|
||||
for ev in matched:
|
||||
if ev["event_date"] not in seen:
|
||||
seen.add(ev["event_date"])
|
||||
deduped.append(ev)
|
||||
|
||||
# Build known (date, value) anchor points
|
||||
known: list[tuple[date_type, float]] = []
|
||||
for ev in deduped:
|
||||
try:
|
||||
ev_date = date_type.fromisoformat(ev["event_date"])
|
||||
except ValueError:
|
||||
continue
|
||||
|
||||
if ev_date <= today:
|
||||
# Past event: prefer actual, fall back to forecast then previous
|
||||
v = _parse_ff_num(ev.get("actual_value")) \
|
||||
or _parse_ff_num(ev.get("forecast_value")) \
|
||||
or _parse_ff_num(ev.get("previous_value"))
|
||||
else:
|
||||
# Future event: use forecast, fall back to previous
|
||||
v = _parse_ff_num(ev.get("forecast_value")) \
|
||||
or _parse_ff_num(ev.get("previous_value"))
|
||||
|
||||
if v is not None:
|
||||
known.append((ev_date, v))
|
||||
|
||||
if not known:
|
||||
return {}
|
||||
|
||||
known.sort(key=lambda x: x[0])
|
||||
|
||||
# Build daily timeline via linear interpolation
|
||||
result: dict[str, float] = {}
|
||||
cur = date_from
|
||||
while cur <= date_to:
|
||||
cur_str = str(cur)
|
||||
|
||||
# Find surrounding anchor points
|
||||
prev_k: Optional[tuple[date_type, float]] = None
|
||||
next_k: Optional[tuple[date_type, float]] = None
|
||||
for k_date, k_val in known:
|
||||
if k_date <= cur:
|
||||
prev_k = (k_date, k_val)
|
||||
elif next_k is None:
|
||||
next_k = (k_date, k_val)
|
||||
break
|
||||
|
||||
if prev_k is None and next_k is None:
|
||||
pass # no data at all (shouldn't happen given the wide window)
|
||||
elif prev_k is None:
|
||||
# Before first known anchor: flat at first value
|
||||
result[cur_str] = next_k[1] # type: ignore[index]
|
||||
elif next_k is None:
|
||||
# After last known anchor: flat at last value
|
||||
result[cur_str] = prev_k[1]
|
||||
else:
|
||||
# Interpolate linearly between prev and next anchor
|
||||
total_d = (next_k[0] - prev_k[0]).days
|
||||
elapsed = (cur - prev_k[0]).days
|
||||
frac = elapsed / total_d if total_d > 0 else 0.0
|
||||
result[cur_str] = round(prev_k[1] + frac * (next_k[1] - prev_k[1]), 4)
|
||||
|
||||
cur += timedelta(days=1)
|
||||
|
||||
return result
|
||||
|
||||
|
||||
# ── Saturation scales (tanh) par unité native ─────────────────────────────────
|
||||
# tanh(x/scale) : slope=1 à l'origine, sature asymptotiquement à ±1
|
||||
# pips = coefficient_to_pips * scale * tanh(x / scale)
|
||||
@@ -1078,51 +1251,73 @@ def simulate_timeline(
|
||||
|
||||
from services.causal_graphs import evaluate_graph
|
||||
|
||||
# Structural pips — calculé une seule fois (overrides statiques, pas d'events)
|
||||
gj_struct = _graph_json_for_eval(graph_def, {})
|
||||
inputs_struct = _build_inputs(graph_def, overrides, {}, saturation=True)
|
||||
vals_struct = evaluate_graph(gj_struct, inputs_struct)
|
||||
structural_pips = round(float(vals_struct.get(output_id, 0.0)), 1)
|
||||
fundamental_level_base = round(price_intercept + structural_pips * pip_to_price, 6)
|
||||
# ── Macro-guidance : noeuds input_manual avec macro_key → overrides time-varying ──
|
||||
macro_node_timelines: dict[str, dict[str, float]] = {}
|
||||
for node in graph_def.get("nodes", []):
|
||||
mk = node.get("macro_key")
|
||||
if mk and node.get("node_type") == "input_manual":
|
||||
tl = build_macro_node_timeline(conn, mk, date_from, today)
|
||||
if tl:
|
||||
macro_node_timelines[node["id"]] = tl
|
||||
|
||||
# Guidance EMA : la baseline de la synthétique est l'EMA lissée du prix réel.
|
||||
# synthetic_price(t) = EMA(t) + event_pips(t) × pip_to_price
|
||||
# → sans event perturbateur : synthétique colle au lissé historique
|
||||
# → avec events : déviation proportionnelle à leur contribution
|
||||
ema_prices: dict[str, float] = {}
|
||||
last_ema: float = fundamental_level_base # fallback si pas de données prix
|
||||
has_macro = bool(macro_node_timelines)
|
||||
|
||||
# ── Structural baseline (static si pas de macro nodes) ─────────────────────
|
||||
gj_struct = _graph_json_for_eval(graph_def, {})
|
||||
inputs_struct = _build_inputs(graph_def, overrides, {}, saturation=True)
|
||||
vals_struct = evaluate_graph(gj_struct, inputs_struct)
|
||||
static_structural = round(float(vals_struct.get(output_id, 0.0)), 1)
|
||||
|
||||
# ── Auto-anchor : offset pour que la synthétique parte du prix réel à date_from ──
|
||||
# Calculé une seule fois sur le prix réel à date_from (ou le plus proche disponible).
|
||||
# Cet offset compense l'écart de calibration sans changer la dynamique du modèle.
|
||||
start_offset = 0.0
|
||||
try:
|
||||
# 30j de warmup avant date_from pour que l'EMA soit stabilisée dès le début
|
||||
warmup_from = str(date_from - timedelta(days=30))
|
||||
ph_rows = conn.execute(
|
||||
"""SELECT date, close FROM price_history_cache
|
||||
WHERE instrument=? AND date>=? ORDER BY date ASC""",
|
||||
(inst_upper, warmup_from)
|
||||
).fetchall()
|
||||
alpha = 0.15 # lissage EMA (~6j de demi-vie)
|
||||
ema_val: Optional[float] = None
|
||||
for r in ph_rows:
|
||||
c = float(r["close"])
|
||||
ema_val = c if ema_val is None else alpha * c + (1.0 - alpha) * ema_val
|
||||
if r["date"] >= str(date_from):
|
||||
ema_prices[r["date"]] = round(ema_val, 6)
|
||||
if ema_prices:
|
||||
last_ema = list(ema_prices.values())[-1]
|
||||
anchor_row = conn.execute(
|
||||
"""SELECT close FROM price_history_cache
|
||||
WHERE instrument=? AND date>=? ORDER BY date ASC LIMIT 1""",
|
||||
(inst_upper, str(date_from))
|
||||
).fetchone()
|
||||
if anchor_row:
|
||||
actual_start = float(anchor_row["close"])
|
||||
if has_macro:
|
||||
# Structural avec valeurs macro au moment de l'ancrage
|
||||
anchor_overrides = dict(overrides)
|
||||
for node_id, tl in macro_node_timelines.items():
|
||||
v = tl.get(str(date_from))
|
||||
if v is None and tl:
|
||||
# Valeur la plus proche avant date_from
|
||||
v = next((tl[d] for d in sorted(tl) if d <= str(date_from)), next(iter(tl.values()), None))
|
||||
if v is not None:
|
||||
anchor_overrides[node_id] = {"value": v, "note": "anchor", "set_at": ""}
|
||||
gj_a = _graph_json_for_eval(graph_def, {})
|
||||
in_a = _build_inputs(graph_def, anchor_overrides, {}, saturation=True)
|
||||
vs_a = evaluate_graph(gj_a, in_a)
|
||||
struct_t0 = float(vs_a.get(output_id, 0.0))
|
||||
else:
|
||||
struct_t0 = static_structural
|
||||
model_start = price_intercept + struct_t0 * pip_to_price
|
||||
start_offset = round(actual_start - model_start, 6)
|
||||
except Exception:
|
||||
pass
|
||||
start_offset = 0.0
|
||||
|
||||
# Dernier override macro connu (gap-fill pour weekends/jours sans données)
|
||||
macro_last: dict[str, float] = {}
|
||||
for node_id, tl in macro_node_timelines.items():
|
||||
v0 = tl.get(str(date_from))
|
||||
if v0 is not None:
|
||||
macro_last[node_id] = v0
|
||||
|
||||
timeline = []
|
||||
cur = date_from
|
||||
while cur <= today:
|
||||
# Accumule les events virtuels (What-if) actifs ce jour
|
||||
cur_str = str(cur)
|
||||
|
||||
# ── Accumule les events virtuels (What-if) actifs ce jour ─────────────
|
||||
ev_by_cat: dict[str, float] = {}
|
||||
active_events_detail: list[dict] = []
|
||||
for ev in events:
|
||||
if ev["ev_date"] > cur:
|
||||
continue
|
||||
if ev["ev_date"] < date_from:
|
||||
# Events avant la fenêtre ne portent pas de lifecycle dans la simu
|
||||
# (leur impact est absorbé dans l'auto-anchor du prix de départ)
|
||||
if ev["ev_date"] > cur or ev["ev_date"] < date_from:
|
||||
continue
|
||||
days = (cur - ev["ev_date"]).days
|
||||
df = _lifecycle(days, ev["rise"], ev["plateau"], ev["absorption"], ev["dtype"])
|
||||
@@ -1140,40 +1335,64 @@ def simulate_timeline(
|
||||
"category": cat,
|
||||
})
|
||||
|
||||
if ev_by_cat:
|
||||
# Des events virtuels sont actifs → recalcul complet avec régime
|
||||
ri = detect_regime(ev_by_cat)
|
||||
gj = _graph_json_for_eval(graph_def, ri["weights"])
|
||||
inputs = _build_inputs(graph_def, overrides, ev_by_cat, saturation=True)
|
||||
vals = evaluate_graph(gj, inputs)
|
||||
net = round(float(vals.get(output_id, 0.0)), 1)
|
||||
regime_label = ri["regime"]
|
||||
else:
|
||||
# Pas d'events — on réutilise les valeurs structurelles
|
||||
vals = vals_struct
|
||||
net = structural_pips
|
||||
regime_label = "BALANCED"
|
||||
# ── Overrides pour ce jour (statiques + time-varying macro) ───────────
|
||||
if has_macro:
|
||||
cur_overrides = dict(overrides)
|
||||
for node_id, tl in macro_node_timelines.items():
|
||||
v = tl.get(cur_str)
|
||||
if v is not None:
|
||||
macro_last[node_id] = v
|
||||
else:
|
||||
v = macro_last.get(node_id) # gap-fill (weekend)
|
||||
if v is not None:
|
||||
cur_overrides[node_id] = {"value": v, "note": "macro_guidance", "set_at": ""}
|
||||
|
||||
# Guide price : EMA du prix réel si disponible, sinon dernier EMA connu (futur)
|
||||
date_str = str(cur)
|
||||
if date_str in ema_prices:
|
||||
guide_price = ema_prices[date_str]
|
||||
last_ema = guide_price
|
||||
else:
|
||||
guide_price = last_ema # dates futures : tient le dernier EMA connu
|
||||
# Structural pips time-varying (sans events, avec macro overrides du jour)
|
||||
gj_s = _graph_json_for_eval(graph_def, {})
|
||||
in_s = _build_inputs(graph_def, cur_overrides, {}, saturation=True)
|
||||
vs_s = evaluate_graph(gj_s, in_s)
|
||||
structural_pips_t = round(float(vs_s.get(output_id, 0.0)), 1)
|
||||
|
||||
event_pips = round(net - structural_pips, 1)
|
||||
if ev_by_cat:
|
||||
ri = detect_regime(ev_by_cat)
|
||||
gj_ = _graph_json_for_eval(graph_def, ri["weights"])
|
||||
in_ = _build_inputs(graph_def, cur_overrides, ev_by_cat, saturation=True)
|
||||
vals = evaluate_graph(gj_, in_)
|
||||
net = round(float(vals.get(output_id, 0.0)), 1)
|
||||
regime_label = ri["regime"]
|
||||
else:
|
||||
vals = vs_s
|
||||
net = structural_pips_t
|
||||
regime_label = "BALANCED"
|
||||
|
||||
else:
|
||||
structural_pips_t = static_structural
|
||||
if ev_by_cat:
|
||||
ri = detect_regime(ev_by_cat)
|
||||
gj = _graph_json_for_eval(graph_def, ri["weights"])
|
||||
inputs = _build_inputs(graph_def, overrides, ev_by_cat, saturation=True)
|
||||
vals = evaluate_graph(gj, inputs)
|
||||
net = round(float(vals.get(output_id, 0.0)), 1)
|
||||
regime_label = ri["regime"]
|
||||
else:
|
||||
vals = vals_struct
|
||||
net = static_structural
|
||||
regime_label = "BALANCED"
|
||||
|
||||
event_pips = round(net - structural_pips_t, 1)
|
||||
fundamental_level = round(price_intercept + structural_pips_t * pip_to_price + start_offset, 6)
|
||||
synthetic_price = round(fundamental_level + event_pips * pip_to_price, 6)
|
||||
|
||||
timeline.append({
|
||||
"date": date_str,
|
||||
"net_pips": net,
|
||||
"structural_pips": structural_pips,
|
||||
"event_pips": event_pips,
|
||||
"fundamental_level": guide_price,
|
||||
"synthetic_price": round(guide_price + event_pips * pip_to_price, 6),
|
||||
"regime": regime_label,
|
||||
"nodes": {k: round(float(v), 1) for k, v in vals.items()},
|
||||
"active_events": active_events_detail,
|
||||
"date": cur_str,
|
||||
"net_pips": net,
|
||||
"structural_pips": structural_pips_t,
|
||||
"event_pips": event_pips,
|
||||
"fundamental_level": fundamental_level,
|
||||
"synthetic_price": synthetic_price,
|
||||
"regime": regime_label,
|
||||
"nodes": {k: round(float(v), 1) for k, v in vals.items()},
|
||||
"active_events": active_events_detail,
|
||||
})
|
||||
cur += timedelta(days=1)
|
||||
|
||||
|
||||
Reference in New Issue
Block a user