You can deploy this model and start earning money today!

tensorlink-dev/
synth-forecaster-1h

Name: synth-forecaster-1h
Availability: InStock

probabilistic-forecasting

crps

Views

No views yet

synth-forecaster-1h

Best model from an evoloop evolutionary optimization campaign.

Results

Metric	Value
crps_total	0.927381
Total experiments	404
Successful	384 (95%)
Max generation	32

Top Experiments

#	Name	Metric	Gen
273	exp_per_asset_model_specialization_xau_simplification	0.927381	28
277	exp_final_production_submission_absolute_closure	0.927381	29
283	exp_threshold_optimization_p70_p80_test	0.927381	29
295	exp_8859	0.927381	29
296	exp_final_production_deployment	0.927381	29

Best Model

Experiment: exp_per_asset_model_specialization_xau_simplification (index 273, generation 28)

Motivation: Testing per-asset model specialization by simplifying XAU to pure AR(1) without jumps while keeping the full 2-regime hybrid jump model for crypto assets (BTC/ETH/SOL). XAU's gold microstructure is fundamentally different from crypto - lighter tails, lower volatility, and more Gaussian behavior - so it may not need complex jump modeling that adds estimation noise without predictive benefit. Hypothesis: XAU will perform equivalently or better with pure AR(1) (no jumps) because: (1) Gold returns are closer to Gaussian with lighter tails than crypto, (2) The jump parameters for XAU (λ=0.005 from sparse 98.5% threshold) are estimated with high variance from limited samples, (3) Removing jumps for XAU eliminates estimation noise while preserving the essential AR(1) microstructure capture. Crypto assets retain jumps due to their heavy-tailed, jump-dominated dynamics. Overall CRPS improves due to better XAU calibration.

python

# Experiment: exp_per_asset_model_specialization_xau_simplification
"""
PER-ASSET MODEL SPECIALIZATION: XAU Simplification Test

The current best model (metric=0.928795) uses a UNIFIED 2-regime AR(1) + hybrid 
jump specification for ALL assets. However, XAU (gold) has fundamentally different
microstructure than crypto assets:
- Lighter tails (near-Gaussian vs heavy-tailed crypto)
- Lower volatility (~0.0002 vs ~0.0004-0.0005 for crypto)
- Different trading dynamics (traditional asset vs 24/7 crypto)

This experiment tests per-asset model specialization:
- XAU: Pure 2-regime AR(1) WITHOUT jumps (simpler, less estimation noise)
- BTC/ETH/SOL: Full 2-regime AR(1) + hybrid jumps (captures heavy tails)

RATIONALE:
- XAU's jump parameters are estimated from sparse events (98.5% threshold)
- With λ≈0.005, we get ~30 jumps per 30-day window - high estimation variance
- Gold's price dynamics may not require explicit jump modeling
- Simpler model for XAU reduces overfitting while preserving key AR(1) structure

HYPOTHESIS: XAU without jumps will perform equivalently or better because
the jump component adds estimation noise without predictive benefit for
near-Gaussian gold returns. Crypto assets retain jumps for tail coverage.
"""

import math
import time
import sys

import numpy as np

from prepare import (
    load_prepared_data,
    get_available_features,
    print_single_challenge_scores,
    gbm_paths,
    run_walk_forward_eval,
    print_walk_forward_summary,
    ASSETS_HFT,
    NUM_SIMULATIONS,
    FORECAST_STEPS_HFT,
    TIME_INCREMENT_HFT,
    TIME_BUDGET,
    CRPS_INTERVALS_HFT,
    N_WALK_FORWARD_SEGMENTS,
    MIN_EVAL_SEGMENTS,
    N_SEEDS_PER_SEGMENT,
)

# ── Configuration ────────────────────────────────────────────────────────

LOOKBACK_DAYS_HFT = 30
TRAIN_FRACTION = 0.85
INPUT_LEN_HFT = 60
HORIZON_STEPS_HFT = [1, 2, 5, 15, 30, 60]
TIME_SPLIT_HFT = 0.9

# Universal threshold for regime classification
REGIME_THRESHOLD_PCT = 75

# Per-asset RV window calibration
PER_ASSET_RV_WINDOW = {
    'BTC': 5,
    'ETH': 5,
    'XAU': 3,
    'SOL': 10,
}

# Universal Huber c
UNIVERSAL_HUBER_C = 1.345

# 3-TIER JUMP THRESHOLD CALIBRATION (crypto assets only)
PER_ASSET_JUMP_PERCENTILE = {
    'BTC': 99.0,
    'ETH': 99.0,
    'XAU': 98.5,  # Not used - XAU has no jumps
    'SOL': 99.5,
}

# Minimum jumps threshold per asset
PER_ASSET_MIN_JUMPS = {
    'BTC': 5,
    'ETH': 5,
    'XAU': 3,
    'SOL': 7,
}

# Universal Poisson jump intensity
UNIVERSAL_LAMBDA = 0.01

# Annualization factor for 1-minute data
ANNUALIZATION_FACTOR = 525960

# HYBRID TAIL PARAMETERS (crypto assets only)
PARETO_ALPHA_DOWN = 1.3
UNIVERSAL_GAUSSIAN_SCALE_UP = 0.0010
UNIVERSAL_P_UP = 0.5
UNIVERSAL_PHI = -0.05

# Model specialization flags
ASSET_MODEL_TYPE = {
    'BTC': 'full',      # 2-regime AR(1) + hybrid jumps
    'ETH': 'full',      # 2-regime AR(1) + hybrid jumps
    'XAU': 'no_jumps',  # 2-regime AR(1) only (no jumps)
    'SOL': 'full',      # 2-regime AR(1) + hybrid jumps
}

# Bounds for numerical stability
MIN_PARETO_ALPHA = 1.1
MAX_PARETO_ALPHA = 5.0


# ── Core Model Functions ─────────────────────────────────────────────────

def fit_robust_ar1_for_sigma_only(returns, huber_c=1.345, max_iter=50, tol=1e-6):
    """
    Fit AR(1) using Huber M-estimator, but only return sigma (not phi).
    Phi will be set universally.
    """
    if len(returns) < 10:
        return np.std(returns) if len(returns) > 1 else 0.001
    
    phi = UNIVERSAL_PHI
    
    r_t = returns[1:]
    r_tminus1 = returns[:-1]
    
    valid = np.isfinite(r_t) & np.isfinite(r_tminus1)
    if not np.any(valid):
        return np.std(returns) if len(returns) > 1 else 0.001
    
    r_t = r_t[valid]
    r_tminus1 = r_tminus1[valid]
    n = len(r_t)
    
    if n < 5:
        return np.std(returns) if len(returns) > 1 else 0.001
    
    residuals = r_t - phi * r_tminus1
    
    c = huber_c
    for _ in range(max_iter):
        mad = np.median(np.abs(residuals - np.median(residuals)))
        sigma_scale = mad / 0.6745 if mad > 1e-12 else 1.0
        
        standardized = residuals / max(sigma_scale, 1e-12)
        abs_r = np.abs(standardized)
        weights = np.ones_like(residuals)
        mask = abs_r > c
        weights[mask] = c / abs_r[mask]
        
        weighted_residuals = weights * residuals
        residuals = r_t - phi * r_tminus1
    
    mad_final = np.median(np.abs(residuals - np.median(residuals)))
    sigma = mad_final / 0.6745
    
    if sigma < 1e-8 or not np.isfinite(sigma):
        sigma = np.std(residuals)
    
    return sigma


def compute_realized_volatility(returns, window):
    """
    Compute realized volatility using simple close-to-close returns.
    """
    n = len(returns)
    if n < window:
        return np.full(n, np.std(returns) * np.sqrt(ANNUALIZATION_FACTOR) if n > 1 else 0.001)
    
    rv_history = np.zeros(n)
    for i in range(n):
        start_idx = max(0, i - window)
        window_returns = returns[start_idx:i+1]
        if len(window_returns) > 1:
            rv_history[i] = np.std(window_returns) * np.sqrt(ANNUALIZATION_FACTOR)
        else:
            rv_history[i] = rv_history[i-1] if i > 0 else 0.001
    
    return rv_history


def estimate_jump_parameters_universal(returns, asset):
    """
    Estimate jump parameters with universal directional probability.
    For XAU, returns zero jumps (model specialization).
    """
    model_type = ASSET_MODEL_TYPE.get(asset, 'full')
    
    # XAU uses no-jump model
    if model_type == 'no_jumps':
        return 0.0, UNIVERSAL_P_UP, UNIVERSAL_GAUSSIAN_SCALE_UP, 0.001, 0.001
    
    if len(returns) < 100:
        return 0.0, UNIVERSAL_P_UP, UNIVERSAL_GAUSSIAN_SCALE_UP, 0.001, 0.001
    
    jump_percentile = PER_ASSET_JUMP_PERCENTILE.get(asset, 99.0)
    min_jumps = PER_ASSET_MIN_JUMPS.get(asset, 5)
    
    abs_returns = np.abs(returns)
    threshold = np.percentile(abs_returns, jump_percentile)
    
    jump_mask = abs_returns > threshold
    n_jumps = np.sum(jump_mask)
    
    if n_jumps < min_jumps:
        return 0.0, UNIVERSAL_P_UP, UNIVERSAL_GAUSSIAN_SCALE_UP, PARETO_ALPHA_DOWN, threshold
    
    lambda_poisson = UNIVERSAL_LAMBDA
    p_up = UNIVERSAL_P_UP
    gaussian_sigma_up = UNIVERSAL_GAUSSIAN_SCALE_UP
    pareto_scale_down = threshold
    
    return lambda_poisson, p_up, gaussian_sigma_up, pareto_scale_down, threshold


def fit_model(returns, asset):
    """
    Fit 2-regime AR(1) with per-asset model specialization.
    """
    rv_window = PER_ASSET_RV_WINDOW.get(asset, 5)
    model_type = ASSET_MODEL_TYPE.get(asset, 'full')
    
    if len(returns) < 100:
        sigma = fit_robust_ar1_for_sigma_only(returns, huber_c=UNIVERSAL_HUBER_C)
        threshold = np.percentile(np.abs(returns), 99.0) if len(returns) > 10 else 0.001
        return {
            'phi': UNIVERSAL_PHI,
            'sigma_calm': sigma,
            'sigma_volatile': sigma,
            'vol_threshold': np.inf,
            'regime': 'calm',
            'use_regime': False,
            'lambda_poisson': 0.0,
            'p_up': UNIVERSAL_P_UP,
            'gaussian_sigma_up': UNIVERSAL_GAUSSIAN_SCALE_UP,
            'pareto_scale_down': threshold,
            'jump_threshold': threshold,
            'rv_window': rv_window,
            'model_type': model_type,
            'jump_percentile': PER_ASSET_JUMP_PERCENTILE.get(asset, 99.0),
        }
    
    phi = UNIVERSAL_PHI
    sigma_overall = fit_robust_ar1_for_sigma_only(returns, huber_c=UNIVERSAL_HUBER_C)
    
    # Estimate jump parameters (zero for XAU)
    lambda_poisson, p_up, gaussian_sigma_up, pareto_scale_down, jump_threshold = estimate_jump_parameters_universal(returns, asset)
    
    # Compute RV history for regime classification
    rv_history = compute_realized_volatility(returns, rv_window)
    
    valid_rv = rv_history[np.isfinite(rv_history)]
    if len(valid_rv) == 0:
        valid_rv = np.array([sigma_overall])
    
    vol_threshold = np.percentile(valid_rv, REGIME_THRESHOLD_PCT)
    
    calm_mask = rv_history < vol_threshold
    volatile_mask = ~calm_mask
    
    # Regime-specific sigma estimation using universal phi
    returns_lag = returns[:-1]
    returns_curr = returns[1:]
    
    if np.sum(calm_mask[:-1]) > 10:
        calm_idx = np.where(calm_mask[:-1])[0]
        residuals_calm = returns_curr[calm_idx] - phi * returns_lag[calm_idx]
        mad_calm = np.median(np.abs(residuals_calm - np.median(residuals_calm)))
        sigma_calm = mad_calm / 0.6745
    else:
        sigma_calm = sigma_overall
    
    if np.sum(volatile_mask[:-1]) > 10:
        volatile_idx = np.where(volatile_mask[:-1])[0]
        residuals_volatile = returns_curr[volatile_idx] - phi * returns_lag[volatile_idx]
        mad_volatile = np.median(np.abs(residuals_volatile - np.median(residuals_volatile)))
        sigma_volatile = mad_volatile / 0.6745
    else:
        sigma_volatile = sigma_overall * 1.5
    
    if sigma_volatile <= sigma_calm:
        sigma_volatile = sigma_calm * 1.3
    
    current_rv = rv_history[-1] if len(rv_history) > 0 and np.isfinite(rv_history[-1]) else sigma_overall
    current_regime = 'volatile' if current_rv > vol_threshold else 'calm'
    
    return {
        'phi': phi,
        'sigma_calm': sigma_calm,
        'sigma_volatile': sigma_volatile,
        'vol_threshold': vol_threshold,
        'regime': current_regime,
        'use_regime': True,
        'lambda_poisson': lambda_poisson,
        'p_up': p_up,
        'gaussian_sigma_up': gaussian_sigma_up,
        'pareto_scale_down': pareto_scale_down,
        'jump_threshold': jump_threshold,
        'rv_window': rv_window,
        'model_type': model_type,
        'jump_percentile': PER_ASSET_JUMP_PERCENTILE.get(asset, 99.0),
    }


def train_model(data_hft, assets):
    """Train 2-regime AR(1) with per-asset model specialization."""
    print("=" * 60)
    print("PER-ASSET MODEL SPECIALIZATION: XAU Simplification Test")
    print("=" * 60)
    print("Testing different model families per asset:")
    for asset in assets:
        model_type = ASSET_MODEL_TYPE.get(asset, 'full')
        if model_type == 'full':
            print(f"  {asset}: 2-regime AR(1) + hybrid jumps")
        else:
            print(f"  {asset}: 2-regime AR(1) NO JUMPS (simplified)")
    print("-" * 60)
    print("Universal parameters:")
    print(f"  phi={UNIVERSAL_PHI:.4f}, p_up={UNIVERSAL_P_UP:.2f}, scale={UNIVERSAL_GAUSSIAN_SCALE_UP:.4f}")
    print("-" * 60)
    
    model_params = {}
    
    for asset in assets:
        if asset not in data_hft:
            continue
            
        df = data_hft[asset]
        prices = df['close'].values
        log_prices = np.log(prices)
        returns = np.diff(log_prices)
        returns = returns[np.isfinite(returns)]
        
        if len(returns) < 10:
            threshold = 0.001
            model_type = ASSET_MODEL_TYPE.get(asset, 'full')
            model_params[asset] = {
                'phi': UNIVERSAL_PHI, 'sigma_calm': 0.001, 'sigma_volatile': 0.001,
                'vol_threshold': np.inf, 'regime': 'calm', 'use_regime': False,
                'lambda_poisson': 0.0, 'p_up': UNIVERSAL_P_UP,
                'gaussian_sigma_up': UNIVERSAL_GAUSSIAN_SCALE_UP, 
                'pareto_scale_down': threshold,
                'jump_threshold': threshold, 'rv_window': PER_ASSET_RV_WINDOW.get(asset, 5),
                'model_type': model_type,
                'jump_percentile': PER_ASSET_JUMP_PERCENTILE.get(asset, 99.0),
            }
            continue
        
        params = fit_model(returns, asset)
        params['last_return'] = returns[-1] if len(returns) > 0 else 0.0
        model_params[asset] = params
        
        reg_str = f"[{params['regime'].upper()}]"
        model_type = params['model_type']
        if model_type == 'full':
            jump_str = f" λ={params['lambda_poisson']:.4f}"
        else:
            jump_str = " NO-JUMPS"
        print(f"  {asset}: phi={params['phi']:.4f}, "
              f"σ_calm={params['sigma_calm']:.6f}, σ_vol={params['sigma_volatile']:.6f}, "
              f"p↑={params['p_up']:.2f}{jump_str} {reg_str}")
    
    return {'model_params': model_params}


def generate_pareto_jumps(num_samples, alpha, scale):
    """
    Generate Pareto-distributed random variables.
    """
    u = np.random.random(num_samples)
    u = np.clip(u, 1e-10, 1.0)
    jumps = scale * (u ** (-1.0 / alpha))
    max_jump = scale * 100
    jumps = np.clip(jumps, scale, max_jump)
    return jumps


def generate_gaussian_jumps(num_samples, sigma):
    """
    Generate Gaussian-distributed random variables (truncated to positive).
    """
    jumps = np.random.normal(0.0, sigma, num_samples)
    jumps = np.maximum(jumps, 0.001)
    max_jump = sigma * 10
    jumps = np.clip(jumps, 0.001, max_jump)
    return jumps


def generate_paths(
    current_price: float,
    historical_prices: np.ndarray,
    forecast_steps: int,
    time_increment: int,
    num_simulations: int,
    phi: float,
    sigma_calm: float,
    sigma_volatile: float,
    vol_threshold: float,
    current_regime: str,
    use_regime: bool,
    lambda_poisson: float,
    p_up: float,
    gaussian_sigma_up: float,
    pareto_scale_down: float,
    jump_threshold: float,
    rv_window: int = 5,
    model_type: str = 'full',
):
    """
    Generate price paths using 2-regime AR(1) with per-asset specialization.
    """
    if not use_regime:
        sigma_eff = sigma_calm
    else:
        log_prices = np.log(historical_prices)
        returns = np.diff(log_prices)
        recent_returns = returns[-rv_window:] if len(returns) >= rv_window else returns
        
        current_rv = np.std(recent_returns) * np.sqrt(ANNUALIZATION_FACTOR) if len(recent_returns) > 1 else sigma_calm
        sigma_eff = sigma_volatile if current_rv > vol_threshold else sigma_calm
    
    sigma_eff = np.clip(sigma_eff, 1e-6, 0.5)
    
    current_log_price = np.log(current_price)
    log_paths = np.zeros((num_simulations, forecast_steps))
    log_paths[:, 0] = current_log_price
    
    if len(historical_prices) >= 2:
        last_return = np.log(historical_prices[-1]) - np.log(historical_prices[-2])
    else:
        last_return = 0.0
    
    current_returns = np.full(num_simulations, last_return)
    
    eps_normal = np.random.normal(0.0, 1.0, (num_simulations, forecast_steps))
    
    # Jump arrivals - only for 'full' model type
    if model_type == 'full' and lambda_poisson > 0:
        jump_prob = 1.0 - np.exp(-lambda_poisson)
        jump_occurs = np.random.random((num_simulations, forecast_steps)) < jump_prob
    else:
        jump_occurs = np.zeros((num_simulations, forecast_steps), dtype=bool)
    
    for t in range(1, forecast_steps):
        continuous_innov = phi * current_returns + sigma_eff * eps_normal[:, t]
        
        jump_innov = np.zeros(num_simulations)
        jumping_paths = jump_occurs[:, t]
        n_jumping = np.sum(jumping_paths)
        
        if n_jumping > 0:
            up_mask = np.random.random(n_jumping) < p_up
            n_up = np.sum(up_mask)
            n_down = n_jumping - n_up
            
            up_jumps = generate_gaussian_jumps(n_up, gaussian_sigma_up)
            down_jumps = -generate_pareto_jumps(n_down, PARETO_ALPHA_DOWN, pareto_scale_down)
            
            jump_values = np.concatenate([up_jumps, down_jumps])
            jump_innov[jumping_paths] = jump_values
        
        new_return = continuous_innov + jump_innov
        log_paths[:, t] = log_paths[:, t-1] + new_return
        current_returns = new_return
    
    paths = np.exp(log_paths)
    paths[:, 0] = current_price
    
    return paths


def generate_predictions(
    current_price: float,
    historical_prices: np.ndarray,
    forecast_steps: int,
    time_increment: int,
    num_simulations: int = 1000,
    model=None,
    features: np.ndarray = None,
    horizon_steps=None,
) -> np.ndarray:
    """
    Generate predictions using per-asset model specialization.
    """
    if model is None:
        return gbm_paths(
            current_price=current_price,
            historical_prices=historical_prices,
            num_steps=forecast_steps,
            num_simulations=num_simulations,
            time_increment=time_increment,
        )
    
    model_params = model.get('model_params', {})
    asset_params = model_params.get(model.get('current_asset', ''), {})
    
    return generate_paths(
        current_price=current_price,
        historical_prices=historical_prices,
        forecast_steps=forecast_steps,
        time_increment=time_increment,
        num_simulations=num_simulations,
        phi=asset_params.get('phi', UNIVERSAL_PHI),
        sigma_calm=asset_params.get('sigma_calm', 0.001),
        sigma_volatile=asset_params.get('sigma_volatile', 0.001),
        vol_threshold=asset_params.get('vol_threshold', np.inf),
        current_regime=asset_params.get('regime', 'calm'),
        use_regime=asset_params.get('use_regime', False),
        lambda_poisson=asset_params.get('lambda_poisson', 0.0),
        p_up=asset_params.get('p_up', UNIVERSAL_P_UP),
        gaussian_sigma_up=asset_params.get('gaussian_sigma_up', UNIVERSAL_GAUSSIAN_SCALE_UP),
        pareto_scale_down=asset_params.get('pareto_scale_down', 0.001),
        jump_threshold=asset_params.get('jump_threshold', 0.001),
        rv_window=asset_params.get('rv_window', 5),
        model_type=asset_params.get('model_type', 'full'),
    )


# ── Main ─────────────────────────────────────────────────────────────────

def main():
    start_time = time.time()
    peak_vram = 0.0

    print("=" * 60)
    print("SYNTH 1H HIGH FREQUENCY - Per-Asset Model Specialization")
    print("=" * 60, flush=True)
    print("Testing XAU simplification (no jumps) vs crypto full model")
    print("  XAU: 2-regime AR(1) without jumps (simplified)")
    print("  BTC/ETH/SOL: 2-regime AR(1) + hybrid jumps (full)")
    print(f"  Universal: phi={UNIVERSAL_PHI:.4f}, p_up={UNIVERSAL_P_UP:.2f}")
    print("-" * 60, flush=True)

    try:
        data_hft = load_prepared_data(
            lookback_days=LOOKBACK_DAYS_HFT, assets=ASSETS_HFT, interval="1m",
        )
    except RuntimeError as e:
        print(f"FATAL: {e}", file=sys.stderr, flush=True)
        print(f"data_error: {e}")
        print("crps_total: 999999.0")
        print(f"training_seconds: {time.time() - start_time:.1f}")
        print("peak_vram_mb: 0.0")
        sys.exit(1)

    trained_model = train_model(data_hft, ASSETS_HFT)

    predictions_hft = {}
    actuals_hft = {}
    per_asset_crps_hft = {}
    per_asset_se_hft = {}
    per_asset_segments = {}
    wf_gbm_hft = {}

    budget_hft = TIME_BUDGET * TIME_SPLIT_HFT

    for asset in ASSETS_HFT:
        if asset not in data_hft:
            print(f"  Skipping {asset} HFT (no data)", flush=True)
            continue

        if time.time() - start_time > budget_hft:
            print(f"  Time budget exhausted, skipping remaining assets", flush=True)
            break

        df = data_hft[asset]
        feature_cols = get_available_features(df)

        model = {
            'model_params': trained_model['model_params'],
            'current_asset': asset,
        }

        result = run_walk_forward_eval(
            asset=asset,
            df=df,
            feature_cols=feature_cols,
            generate_predictions_fn=generate_predictions,
            input_len=INPUT_LEN_HFT,
            horizon_steps=HORIZON_STEPS_HFT,
            forecast_steps=FORECAST_STEPS_HFT,
            time_increment=TIME_INCREMENT_HFT,
            intervals=CRPS_INTERVALS_HFT,
            model=model,
        )

        if result is not None:
            current_price, paths, actual_prices, scores, gbm_scores, n_segs, se = result
            predictions_hft[asset] = (current_price, paths)
            actuals_hft[asset] = actual_prices
            per_asset_crps_hft[asset] = scores
            per_asset_se_hft[asset] = se
            per_asset_segments[asset] = n_segs
            wf_gbm_hft[asset] = gbm_scores
            total_crps = sum(scores.values())
            total_se = math.sqrt(sum(v * v for v in se.values()))
            warn = " [INSUFFICIENT]" if n_segs < MIN_EVAL_SEGMENTS else ""
            print(
                f"  {asset}: CRPS={total_crps:.4f} ± {total_se:.4f} SE "
                f"({n_segs} segments × {N_SEEDS_PER_SEGMENT} seeds){warn}",
                flush=True,
            )

    elapsed = time.time() - start_time

    print_single_challenge_scores(
        challenge="hft",
        per_asset_crps=per_asset_crps_hft,
        predictions=predictions_hft,
        actuals=actuals_hft,
        data=data_hft,
        elapsed=elapsed,
        peak_vram=peak_vram,
        train_fraction=TRAIN_FRACTION,
        input_len=INPUT_LEN_HFT,
        max_eval_points=N_WALK_FORWARD_SEGMENTS,
    )

    hft_weights = {a: 1.0 for a in ASSETS_HFT}

    print()
    print_walk_forward_summary(
        label="hft",
        per_asset_scores=per_asset_crps_hft,
        per_asset_gbm=wf_gbm_hft,
        per_asset_se=per_asset_se_hft,
        per_asset_segments=per_asset_segments,
        expected_assets=ASSETS_HFT,
        weights=hft_weights,
    )


if __name__ == "__main__":
    main()

Reflection: Reflection: This experiment teaches us that the asymmetric calibration heterogeneity boundary extends beyond parameter calibration to model family selection - but only at the asset class level (traditional vs crypto), not the individual asset level. XAU's 40% lower CRPS reveals that gold's near-Gaussian microstructure makes explicit jump modeling actively harmful due to high-variance estimation from sparse events (~30 jumps per window), while crypto's heavy-tailed dynamics require jumps for tail coverage. This is the first successful per-asset architectural specialization after multiple catastrophic failures, suggesting the key is matching model complexity to empirical tail heaviness: light tails → pure diffusion, heavy tails → jump-diffusion.

Usage

bash

# Install dependencies
pip install torch numpy pandas scipy huggingface_hub

# Run the best model
python train.py

How It Was Made

This model was evolved using evoloop, an LLM-driven evolutionary code optimization system. Starting from a seed baseline, the system iteratively mutated the training code across 404 experiments over 32 generations, guided by CRPS scoring and research hypotheses.

Files

train.py — The evolved training script (best experiment)
prepare.py — Frozen evaluation harness (data loading + CRPS scoring)
task.yaml — Task configuration for evoloop
report.json — Full experiment report with metrics
experiments.jsonl — Complete experiment history

tensorlink-dev/synth-forecaster-1h