Microstructure/tests/test_models.py

from __future__ import annotations

import numpy as np
import polars as pl
import pytest

from microstructure.config import EvaluationConfig, ModelConfig
from microstructure.research.models import (
    ModelEvaluationError,
    SigmoidCalibrator,
    block_bootstrap_metric,
    build_model_candidates,
    classification_metrics,
    evaluate_model_ladder,
    paired_block_bootstrap_difference,
)
from microstructure.research.splits import expanding_walk_forward_splits


def _evaluation_config() -> EvaluationConfig:
    return EvaluationConfig(
        min_train_events=20,
        validation_events=8,
        test_events=8,
        step_events=8,
        embargo_events=1,
        bootstrap_samples=40,
        calibration_bins=5,
    )


def _model_config() -> ModelConfig:
    return ModelConfig(
        selection_metric="log_loss",
        logistic_c_values=(1.0,),
        tree_max_depth_values=(2,),
        tree_min_samples_leaf=1,
    )


def _model_frame() -> pl.DataFrame:
    rows: list[dict[str, object]] = []
    for decision in range(48):
        positive = decision % 2
        for symbol_offset, symbol in enumerate(("BTCUSDT", "ETHUSDT")):
            censored = decision == 47
            rows.append(
                {
                    "symbol": symbol,
                    "decision_ts_ns": decision,
                    "label_information_end_ts_ns": None if censored else decision + 1,
                    "right_censored": censored,
                    "future_mid_up": None if censored else positive,
                    "future_mid_return": None if censored else (0.001 if positive else -0.001),
                    "feature_ready": True,
                    "spread_bps": 2.0 + 0.1 * symbol_offset,
                    "depth_total_l1": 20.0,
                    "queue_imbalance_l1": 0.8 if positive else -0.8,
                    "microprice_deviation_bps": 0.5 if positive else -0.5,
                    "ofi_l1": 2.0 if positive else -2.0,
                    "log_mid_return_1": 0.0001 if positive else -0.0001,
                    "ofi_w2": 3.0 if positive else -3.0,
                    "signed_trade_volume_w2": 4.0 if positive else -4.0,
                    "trade_volume_w2": 4.0,
                    "trade_count_w2": 1.0,
                    "trade_intensity_w2": 2.0,
                    "realized_volatility_w2": 0.001,
                }
            )
    return pl.DataFrame(rows).sort(["decision_ts_ns", "symbol"])


def test_model_ladder_contains_required_transparent_families() -> None:
    candidates = build_model_candidates(_model_config())
    assert [candidate.family for candidate in candidates] == [
        "baseline",
        "logistic",
        "logistic_l2",
        "shallow_tree",
    ]


def test_out_of_time_ladder_is_deterministic_and_test_is_not_selected_on() -> None:
    frame = _model_frame()
    plan = expanding_walk_forward_splits(frame, _evaluation_config())
    first = evaluate_model_ladder(
        frame,
        plan,
        _model_config(),
        seed=7,
        calibration_bins=5,
    )
    second = evaluate_model_ladder(
        frame,
        plan,
        _model_config(),
        seed=7,
        calibration_bins=5,
    )

    assert first.selected_model == second.selected_model
    assert first.comparison.equals(second.comparison)
    assert first.predictions.equals(second.predictions)
    assert first.predictions.get_column("is_oos").all()
    assert first.predictions.filter(
        pl.col("fit_cutoff_ts_ns") >= pl.col("decision_ts_ns")
    ).is_empty()
    assert set(first.comparison.get_column("split")) == {"validation", "test"}
    assert first.comparison.get_column("instrument_scope").unique().to_list() == ["POOLED"]
    assert first.comparison.filter(pl.col("split") == "test").get_column(
        "period_start_ts_ns"
    ).unique().to_list() == [40]
    assert {"sample_id", "decision_sequence"}.issubset(first.predictions.columns)
    selected = first.comparison.filter(pl.col("selected_on_validation"))
    assert selected.get_column("model").unique().to_list() == [first.selected_model]


def test_single_class_fallback_is_labeled_as_prior_and_cannot_win_selection() -> None:
    frame = _model_frame().with_columns(
        pl.when(pl.col("right_censored"))
        .then(None)
        .otherwise(1)
        .cast(pl.Int8)
        .alias("future_mid_up")
    )
    plan = expanding_walk_forward_splits(frame, _evaluation_config())
    result = evaluate_model_ladder(
        frame,
        plan,
        _model_config(),
        seed=7,
        calibration_bins=5,
    )

    fallback = result.comparison.filter(pl.col("requested_family") != "baseline")
    assert fallback.get_column("family").unique().to_list() == ["baseline"]
    assert fallback.get_column("model").str.ends_with("__prior_fallback").all()
    assert fallback.get_column("fit_status").str.contains("single_class_prior_fallback").all()
    assert result.selected_model == "historical_prior"


def test_label_columns_are_rejected_from_feature_allowlist() -> None:
    frame = _model_frame()
    plan = expanding_walk_forward_splits(frame, _evaluation_config())
    with pytest.raises(ModelEvaluationError, match="cannot be model features"):
        evaluate_model_ladder(
            frame,
            plan,
            _model_config(),
            seed=7,
            calibration_bins=5,
            features=("queue_imbalance_l1", "future_mid_return"),
        )


def test_calibration_and_metrics_have_exact_small_values() -> None:
    y_true = np.asarray([0, 1], dtype=np.int64)
    probability = np.asarray([0.1, 0.9], dtype=np.float64)
    metrics = classification_metrics(y_true, probability, calibration_bins=2)
    assert metrics["accuracy"] == 1.0
    assert metrics["brier_score"] == pytest.approx(0.01)
    assert metrics["log_loss"] == pytest.approx(-np.log(0.9))
    assert metrics["expected_calibration_error"] == pytest.approx(0.1)

    calibrator = SigmoidCalibrator()
    calibration_y = np.asarray([0, 0, 0, 0, 0, 1, 1, 1, 1, 1], dtype=np.int64)
    raw = np.linspace(0.2, 0.8, 10, dtype=np.float64)
    calibrator.fit(calibration_y, raw)
    transformed = calibrator.transform(raw)
    assert calibrator.status == "sigmoid"
    assert np.all((transformed >= 0.0) & (transformed <= 1.0))
    assert np.all(np.diff(transformed) > 0)


def test_block_bootstrap_is_seeded_and_paired_identity_is_zero() -> None:
    predictions = pl.DataFrame(
        {
            "row_id": list(range(8)),
            "y_true": [0, 1, 0, 1, 1, 0, 1, 0],
            "probability": [0.1, 0.8, 0.2, 0.7, 0.9, 0.3, 0.6, 0.4],
            "block": ["a", "a", "a", "a", "b", "b", "b", "b"],
        }
    )
    first = block_bootstrap_metric(
        predictions,
        metric="brier_score",
        block_column="block",
        n_bootstrap=40,
        seed=11,
    )
    second = block_bootstrap_metric(
        predictions,
        metric="brier_score",
        block_column="block",
        n_bootstrap=40,
        seed=11,
    )
    assert first == second
    assert first.status == "ok"
    assert first.n_blocks == 2

    paired = paired_block_bootstrap_difference(
        predictions,
        predictions,
        metric="brier_score",
        block_column="block",
        n_bootstrap=40,
        seed=11,
    )
    assert paired.point_estimate == 0.0
    assert paired.lower == 0.0
    assert paired.upper == 0.0
    assert set(paired.draws) == {0.0}