Skip to content

Validation

src.ga.validation

View source code

Evaluate generation elites across deterministic, randomized Pong scenarios.

ValidationScenario dataclass

ai_paddle_x: float instance-attribute

ball_vertical_direction: int instance-attribute

ball_x: float instance-attribute

ball_y: float instance-attribute

cpu_paddle_x: float instance-attribute

duration: float instance-attribute

paddle_width: int instance-attribute

seed: int instance-attribute

__init__(seed: int, duration: float, paddle_width: int, ball_x: float, ball_y: float, ball_vertical_direction: int, ai_paddle_x: float, cpu_paddle_x: float) -> None

EliteValidator

Run a fixed-size scenario suite and measure wins and CPU shutouts.

duration_range = duration_range instance-attribute

fps = fps instance-attribute

games = games instance-attribute

height = height instance-attribute

paddle_width_range = paddle_width_range instance-attribute

seed = seed instance-attribute

shutout_rate_target = shutout_rate_target instance-attribute

speed = speed instance-attribute

steps_per_frame = steps_per_frame instance-attribute

width = width instance-attribute

win_rate_target = win_rate_target instance-attribute

__init__(*, seed: int, games: int = 2, duration_range: tuple[float, float] = (6.0, 18.0), paddle_width_range: tuple[int, int] = (50, 120), win_rate_target: float = 0.95, shutout_rate_target: float = 0.9, fps: float = 144, speed: float = 2.5, steps_per_frame: int = 15, width: int = 476, height: int = 500)

aggregate(generation: int, results: list[dict]) -> dict

Summarize per-scenario outcomes identically for every validation mode.

configure_scenario(game, scenario: ValidationScenario) -> None

Apply the same randomized start state to both rendered and headless scenarios.

evaluate(elite: IndividualPlayer, generation: int) -> dict

Run the shared scenario suite to completion for headless callers.

scenarios_for(generation: int) -> list[ValidationScenario]

start(elite: IndividualPlayer, generation: int, game=None) -> EliteValidationRun

Create a resumable suite; a supplied game is reused by the rendered runner.

EliteValidationRun

Advance elite scenarios incrementally while isolating training RNG streams.

game = game instance-attribute

generation = generation instance-attribute

is_complete: bool property

player = None instance-attribute

result: dict property

results = [] instance-attribute

scenario_index = -1 instance-attribute

scenarios = validator.scenarios_for(generation) instance-attribute

validator = validator instance-attribute

__init__(validator: EliteValidator, elite: IndividualPlayer, generation: int, game=None)

advance(steps: int, step_delta: float) -> None

Run bounded fixed-delta steps; the rendered caller supplies the historical step size.

close() -> None

Restore every training RNG even if a rendered window is closed mid-suite.

run_headless_scenario(step_delta: float) -> None

Preserve the synchronous Game headless runner for existing evaluation callers.