Brummel
d858caf67b
docs/specs and docs/plans were retired (prior commit); the source/test
comments that cited them ("spec 0050 §4.1", "spec §Testing N", "per spec",
"the spec's ...") now point at nothing. Strip every such pointer while
preserving the technical substance, the design-ledger contract refs
(C1/C11/C20/C34/C12.1/...), and the Gitea issue refs (#41).
Comment/doc edits only across 20 files — no logic change; full workspace
suite green, clippy clean.
231 lines
8.5 KiB
Rust
231 lines
8.5 KiB
Rust
//! Runnable World-family demo: **`walk_forward`** the GER40 session-breakout
|
||
//! `Composite` blueprint across multi-year real GER40 history, with a
|
||
//! per-window in-sample optimize of its two genuine tuning knobs
|
||
//! (`entry_bar.target` × `exit_bar.target`). This is the executable #97
|
||
//! resolution: the roll is NON-DEGENERATE — a real, non-empty `param_space()` is
|
||
//! optimized per window, so every window's `chosen_params` is populated (contrast
|
||
//! the earlier fieldtest's empty-space degenerate roll over the raw FlatGraph, on
|
||
//! which no in-sample tuning was possible).
|
||
//!
|
||
//! Run:
|
||
//! ```text
|
||
//! cargo run -p aura-ingest --example ger40_breakout_walkforward
|
||
//! ```
|
||
//! Prints each IS/OOS window with the entry/exit it chose in-sample and its OOS
|
||
//! pips, plus the stitched out-of-sample equity curve. Skips cleanly where the
|
||
//! archive is absent.
|
||
|
||
use std::sync::Arc;
|
||
|
||
use aura_core::{Cell, Scalar, Timestamp};
|
||
use aura_engine::{
|
||
sweep, summarize, walk_forward, GridSpace, RollMode, RunManifest, RunReport, WindowBounds,
|
||
WindowRoller, WindowRun,
|
||
};
|
||
use chrono::TimeZone;
|
||
use chrono_tz::Europe::Berlin;
|
||
use data_server::{DataServer, DEFAULT_DATA_PATH};
|
||
|
||
#[path = "shared/breakout_real.rs"]
|
||
mod breakout_real;
|
||
use breakout_real::*;
|
||
|
||
// The in-sample grid the per-window optimize searches: entry ∈ {2,3,4}, exit ∈
|
||
// {4,5,6} — the two EqConst targets that ARE the blueprint's param_space().
|
||
const ENTRY_BARS: &[i64] = &[2, 3, 4];
|
||
const EXIT_BARS: &[i64] = &[4, 5, 6];
|
||
|
||
/// ns → ms: `open_ohlc_sources` opens by Unix-ms, but `WindowBounds` are
|
||
/// epoch-ns. `aura-ingest` exports only the forward direction, so the inverse is
|
||
/// a local hand-divide (#80, filed).
|
||
fn ns_to_ms(ts: Timestamp) -> i64 {
|
||
ts.0 / 1_000_000
|
||
}
|
||
|
||
/// Bootstrap the blueprint at one grid point, run it over `[from_ms, to_ms]` of
|
||
/// real GER40 OHLC, and fold the recorded equity/held taps into `(RunReport,
|
||
/// equity-segment)`. Fresh blueprint per call (C1).
|
||
fn run_point(
|
||
server: &Arc<DataServer>,
|
||
point: &[Cell],
|
||
from_ms: i64,
|
||
to_ms: i64,
|
||
) -> (RunReport, Vec<(Timestamp, f64)>) {
|
||
let (bp, taps) = ger40_breakout_blueprint(BAR_MINUTES, SESSION_HOUR, SESSION_MINUTE, Berlin);
|
||
let mut h = bp
|
||
.bootstrap_with_cells(point)
|
||
.expect("point kind-checked against param_space");
|
||
let sources =
|
||
open_ohlc_sources(server, from_ms, to_ms).expect("window overlaps GER40 data");
|
||
h.run(sources);
|
||
drop(h);
|
||
let equity: Vec<(Timestamp, f64)> = taps
|
||
.equity
|
||
.try_iter()
|
||
.map(|(t, r)| (t, as_f64(&r[0])))
|
||
.collect();
|
||
let exposure: Vec<(Timestamp, f64)> = taps
|
||
.held
|
||
.try_iter()
|
||
.map(|(t, r)| (t, as_f64(&r[0])))
|
||
.collect();
|
||
let report = RunReport {
|
||
manifest: RunManifest {
|
||
commit: "ger40-breakout-wfo".to_string(),
|
||
params: vec![],
|
||
window: (
|
||
aura_ingest::unix_ms_to_epoch_ns(from_ms),
|
||
aura_ingest::unix_ms_to_epoch_ns(to_ms),
|
||
),
|
||
seed: 0,
|
||
broker: "sim-optimal(pip_size=1)".to_string(),
|
||
},
|
||
metrics: summarize(&equity, &exposure),
|
||
};
|
||
(report, equity)
|
||
}
|
||
|
||
fn main() {
|
||
let server = Arc::new(DataServer::new(DEFAULT_DATA_PATH));
|
||
if !server.has_symbol(SYMBOL) {
|
||
println!("skip: no local data at {DEFAULT_DATA_PATH} (symbol {SYMBOL} absent).");
|
||
return;
|
||
}
|
||
|
||
println!("=== GER40 session-breakout — World `walk_forward` (2018..2024) ===");
|
||
|
||
// The roll span: 2018-01 .. 2024-12. is=12mo, oos=3mo, step=3mo.
|
||
let day_ns: i64 = 86_400_000 * 1_000_000;
|
||
let month_ns: i64 = 30 * day_ns;
|
||
let origin = aura_ingest::unix_ms_to_epoch_ns(
|
||
chrono::Utc.with_ymd_and_hms(2018, 1, 1, 0, 0, 0).unwrap().timestamp_millis(),
|
||
);
|
||
let end = aura_ingest::unix_ms_to_epoch_ns(
|
||
chrono::Utc.with_ymd_and_hms(2024, 12, 31, 23, 59, 59).unwrap().timestamp_millis(),
|
||
);
|
||
let roller = WindowRoller::new(
|
||
(origin, end),
|
||
12 * month_ns,
|
||
3 * month_ns,
|
||
3 * month_ns,
|
||
RollMode::Rolling,
|
||
)
|
||
.expect("span fits >= 1 window");
|
||
|
||
// The non-empty space the per-window in-sample sweep optimizes over: the two
|
||
// genuine tuning knobs (the #97 resolution — a real space to optimize).
|
||
let space = ger40_breakout_blueprint(BAR_MINUTES, SESSION_HOUR, SESSION_MINUTE, Berlin)
|
||
.0
|
||
.param_space();
|
||
println!(
|
||
"optimizing param_space() per window: {:?} (in-sample grid {}×{})",
|
||
space.iter().map(|p| p.name.as_str()).collect::<Vec<_>>(),
|
||
ENTRY_BARS.len(),
|
||
EXIT_BARS.len(),
|
||
);
|
||
println!();
|
||
|
||
let server_for_closure = Arc::clone(&server);
|
||
let space_for_closure = space.clone();
|
||
let result = walk_forward(roller, space, move |w: WindowBounds| -> WindowRun {
|
||
// In-sample optimize: sweep the entry×exit grid over the IS window, choose
|
||
// the point with the best in-sample total_pips. The blueprint is consumed
|
||
// directly via its param_space() — no re-authoring.
|
||
let is_grid = GridSpace::new(
|
||
&space_for_closure,
|
||
space_for_closure
|
||
.iter()
|
||
.map(|ps| match ps.name.as_str() {
|
||
"entry_bar.target" => ENTRY_BARS.iter().map(|&v| Scalar::i64(v)).collect(),
|
||
"exit_bar.target" => EXIT_BARS.iter().map(|&v| Scalar::i64(v)).collect(),
|
||
other => panic!("unexpected param slot {other}"),
|
||
})
|
||
.collect(),
|
||
)
|
||
.expect("IS grid well-formed");
|
||
let (is_from, is_to) = (ns_to_ms(w.is.0), ns_to_ms(w.is.1));
|
||
let is_family = sweep(&is_grid, |pt: &[Cell]| {
|
||
run_point(&server_for_closure, pt, is_from, is_to).0
|
||
});
|
||
let best = is_family
|
||
.points
|
||
.iter()
|
||
.max_by(|a, b| {
|
||
a.report
|
||
.metrics
|
||
.total_pips
|
||
.partial_cmp(&b.report.metrics.total_pips)
|
||
.unwrap_or(std::cmp::Ordering::Equal)
|
||
})
|
||
.expect("the IS grid is non-empty");
|
||
let chosen = best.params.clone();
|
||
|
||
// Apply the chosen params on the OOS window — the honest out-of-sample run.
|
||
let (oos_from, oos_to) = (ns_to_ms(w.oos.0), ns_to_ms(w.oos.1));
|
||
let (oos_report, oos_equity) =
|
||
run_point(&server_for_closure, &chosen, oos_from, oos_to);
|
||
WindowRun { chosen_params: chosen, oos_equity, oos_report }
|
||
});
|
||
|
||
println!("walk-forward produced {} windows\n", result.windows.len());
|
||
println!(
|
||
"{:>3} {:<23} {:<10} {:<9} {:>10} {:>9}",
|
||
"win", "oos-window (UTC date)", "entry_bar", "exit_bar", "oos_pips", "oos_dd"
|
||
);
|
||
println!("{}", "-".repeat(72));
|
||
for (k, w) in result.windows.iter().enumerate() {
|
||
let named = result.named_params(k);
|
||
let entry = named.iter().find(|(n, _)| n == "entry_bar.target").map(|(_, v)| v.as_i64()).unwrap_or(-1);
|
||
let exit = named.iter().find(|(n, _)| n == "exit_bar.target").map(|(_, v)| v.as_i64()).unwrap_or(-1);
|
||
let m = &w.run.oos_report.metrics;
|
||
let win = format!(
|
||
"{}..{}",
|
||
fmt_date(w.bounds.oos.0),
|
||
fmt_date(w.bounds.oos.1),
|
||
);
|
||
println!(
|
||
"{:>3} {:<23} {:<10} {:<9} {:>10.1} {:>9.1}",
|
||
k,
|
||
win,
|
||
entry,
|
||
exit,
|
||
m.total_pips,
|
||
m.max_drawdown,
|
||
);
|
||
}
|
||
|
||
let stitched = &result.stitched_oos_equity;
|
||
println!(
|
||
"\nstitched OOS curve: {} points, final cumulative = {:.1} pips",
|
||
stitched.len(),
|
||
stitched.last().map(|(_, v)| *v).unwrap_or(0.0),
|
||
);
|
||
println!(
|
||
"\nOK: NON-DEGENERATE walk-forward — every window optimized the breakout's\n\
|
||
{}-param space in-sample (chosen_params populated). The #97 empty-space\n\
|
||
degenerate roll is resolved: the strategy ships with a real space to tune.",
|
||
space_param_count(&result.space),
|
||
);
|
||
}
|
||
|
||
fn space_param_count(space: &[aura_engine::ParamSpec]) -> usize {
|
||
space.len()
|
||
}
|
||
|
||
/// Render an epoch-ns timestamp as a UTC `YYYY-MM-DD` for the window column.
|
||
/// Display only — never feeds the graph.
|
||
fn fmt_date(ts: Timestamp) -> String {
|
||
let secs = ts.0.div_euclid(1_000_000_000);
|
||
match chrono::Utc.timestamp_opt(secs, 0).single() {
|
||
Some(dt) => dt.format("%Y-%m-%d").to_string(),
|
||
None => format!("ts={}", ts.0),
|
||
}
|
||
}
|
||
|
||
fn as_f64(s: &Scalar) -> f64 {
|
||
match s {
|
||
Scalar::F64(v) => *v,
|
||
other => panic!("expected f64, got {other:?}"),
|
||
}
|
||
}
|