LEGSTECH Optimizer
47f6012eb2
PROBLEM: Old system repeated identical params, all scores flat at 0.2500,
user had zero control over symbol/TF/dates. Not smart, not dynamic.
NEW ARCHITECTURE:
optimizer/ (NEW package)
├── __init__.py
├── session_config.py User choices (EA, symbol, TF, dates, budget, objective)
├── lhs_sampler.py Latin Hypercube Sampling — diverse exploration
├── result_ranker.py Relative scoring (best in session=1.0, worst=0.0)
├── budget.py Time budget tracker
└── pipeline.py 3-phase orchestrator
Phase 1 — Broad Discovery (LHS, 20-26 runs):
Samples FULL parameter space, not just defaults±tiny step
LHS guarantees coverage: all 17 optimizable LEGSTECH params explored
Relative ranking: profitable configs float top, losers score 0
Phase 2 — Refinement (9 runs):
Neighbor search around top 3 configs at ±20% range (not ±0.5 step)
Keeps best of Phase1 vs Phase2 — never regresses
Phase 3 — Validation (5 runs):
OOS backtest on unseen data period
Sensitivity test: nudge params ±20%, detect fragility
Verdict: RECOMMENDED / RISKY / NOT_RELIABLE
Output: Clean downloadable .set file via /download_set/<run_id>
UI REDESIGN:
ui/templates/landing.html New / homepage (was old dashboard)
ui/templates/setup.html New /setup — EA, symbol, TF, dates, budget, objective
ui/templates/dashboard.html Updated /dashboard with:
- 5-step phase indicator
- Real progress bar per run
- Phase 1 results table (top 5 after phase1)
- Verdict banner with download button
- No-profitable-config warning
ui/static/js/dashboard.js Handles 8 new pipeline SocketIO events
app.py New routes: /, /setup, /dashboard
/api/start accepts full SessionConfig JSON
/download_set/<id> serves optimized .set
ea/registry.py +list_all() for setup page dropdown
ui/templates/reports_index.html Back to Dashboard → /dashboard (was /)
ui/static/css/style.css +dot-warn, dot-done, profit-pos/neg, aliases
FIXES:
Score no longer flat 0.2500 (was: absolute thresholds on losing EA)
User now controls: symbol, timeframe, dates, budget, objective
Parameters now span full range (was: tiny step from defaults)
Verdict is actionable: RECOMMENDED / RISKY / NOT_RELIABLE with reason
TESTED:
8/8 pre-flight checks pass
Browser test: landing ✓, setup form ✓, /dashboard ✓,
phase indicator active ✓, /reports ✓, back link ✓
77 lines
2.6 KiB
Python
77 lines
2.6 KiB
Python
"""
|
|
optimizer/budget.py
|
|
Time budget manager — tracks elapsed time and estimates remaining runs.
|
|
Updates its average-run-time estimate after every completed run.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import time
|
|
from loguru import logger
|
|
|
|
|
|
class BudgetManager:
|
|
"""
|
|
Tracks the time budget for an optimization session.
|
|
|
|
Usage:
|
|
budget = BudgetManager(budget_minutes=60)
|
|
budget.start()
|
|
...after each run:
|
|
budget.record_run(elapsed_seconds)
|
|
if budget.is_exhausted():
|
|
break
|
|
remaining = budget.estimated_runs_remaining()
|
|
"""
|
|
|
|
def __init__(self, budget_minutes: int, initial_seconds_per_run: float = 75.0):
|
|
self.budget_seconds = budget_minutes * 60
|
|
self.avg_seconds_per_run = initial_seconds_per_run
|
|
self._start_ts: float = None
|
|
self._run_times: list[float] = []
|
|
|
|
def start(self) -> None:
|
|
self._start_ts = time.time()
|
|
logger.info(f"BudgetManager: started. Budget = {self.budget_seconds/60:.0f} min")
|
|
|
|
@property
|
|
def elapsed_seconds(self) -> float:
|
|
if self._start_ts is None:
|
|
return 0.0
|
|
return time.time() - self._start_ts
|
|
|
|
@property
|
|
def remaining_seconds(self) -> float:
|
|
return max(0.0, self.budget_seconds - self.elapsed_seconds)
|
|
|
|
@property
|
|
def elapsed_pct(self) -> float:
|
|
return min(100.0, self.elapsed_seconds / self.budget_seconds * 100)
|
|
|
|
def record_run(self, seconds: float) -> None:
|
|
"""Call after each run completes. Updates rolling average."""
|
|
self._run_times.append(seconds)
|
|
# Rolling average (last 5 runs for responsiveness)
|
|
recent = self._run_times[-5:]
|
|
self.avg_seconds_per_run = sum(recent) / len(recent)
|
|
|
|
def estimated_runs_remaining(self) -> int:
|
|
"""How many more runs fit in the remaining budget."""
|
|
if self.avg_seconds_per_run <= 0:
|
|
return 0
|
|
return max(0, int(self.remaining_seconds / self.avg_seconds_per_run))
|
|
|
|
def is_exhausted(self) -> bool:
|
|
"""True when less than 1 average run's time remains."""
|
|
return self.remaining_seconds < self.avg_seconds_per_run
|
|
|
|
def can_fit(self, n_runs: int) -> bool:
|
|
"""True if n_runs more runs fit in remaining budget."""
|
|
return self.remaining_seconds >= n_runs * self.avg_seconds_per_run
|
|
|
|
def summary(self) -> str:
|
|
return (
|
|
f"Budget: {self.elapsed_seconds/60:.1f}/{self.budget_seconds/60:.0f} min used. "
|
|
f"Avg run: {self.avg_seconds_per_run:.0f}s. "
|
|
f"Est. remaining: {self.estimated_runs_remaining()} runs."
|
|
)
|