Struct ScheduleProblem 

pub struct ScheduleProblem {
    pub segments: u32,
    pub x0: f64,
    pub shift: f64,
    pub peak: f64,
    pub penalty: f64,
    pub noise: f64,
    pub lr_low: f64,
    pub lr_high: f64,
}

The nonstationary, schedule-dependent synthetic problem.

The reward for using learning rate lr in segment s is a downward parabola in x = log10(lr) centred on a segment-specific optimum x_opt(s) that decreases with s:

reward(s, lr) = peak − penalty · (x − x_opt(s))²   + small seeded noise
x_opt(s)      = x0 − shift · s                       (high early, low late)

The shift is deliberately matched to PBT’s perturbation granularity (one ×perturb_down step in log10), so a lineage that exploits-and-explores can track the moving optimum one segment at a time — the property that makes this a problem PBT solves rather than one no perturbation scale could follow. It is an honest feature of the fixture, not a thumb on the scale: the fixed baseline and random search face the identical reward.

Fields

segments: u32

How many segments (resource intervals) a full run trains through.

x0: f64

x_opt(0), the optimum log10(lr) for the first segment (the highest).

shift: f64

How far x_opt drops per segment (positive — the optimum moves down).

peak: f64

The maximum per-segment reward (attained at lr == 10^x_opt(s)).

penalty: f64

The curvature of the per-segment reward parabola in log10(lr).

noise: f64

The amplitude of the seeded per-segment noise (RL curves are noisy, and it makes the reward a genuine function of the seed). Kept well below the margins the oracle asserts.

lr_low: f64

The low end of the learning-rate search range.

lr_high: f64

The high end of the learning-rate search range.

Implementations

impl ScheduleProblem

pub fn x_opt(&self, segment: u32) -> f64

The optimal log10(lr) for segment s — high early, low late.

pub fn segment_reward(&self, segment: u32, lr: f64, seed: u64) -> f64

The reward earned by training segment segment with learning rate lr, under the noise realization keyed by seed.

A pure, total function: the downward parabola in log10(lr) plus a small bounded seeded wobble. Segments at or beyond segments earn nothing (the schedule is over), so a lineage’s accumulated reward plateaus at its full-schedule total.

pub fn fixed_total(&self, lr: f64, seed: u64) -> f64

The total reward a fixed learning rate accrues across the whole schedule, under a single reference seed.

pub fn best_fixed(&self, grid: u32, seed: u64) -> (f64, f64)

The best total any fixed learning rate reaches, swept over a dense grid of grid log-spaced values — the strong “best fixed hyperparameter” baseline PBT must beat.

Returns (lr, total).

pub fn ideal_schedule_total(&self, seed: u64) -> f64

The total an ideal schedule — sitting exactly on x_opt(s) at every segment — reaches: segments · peak before noise. The unreachable ceiling the fixed baseline falls short of and PBT climbs toward.

pub fn space(&self) -> Result<SpaceSchema>

The search space a study samples root learning rates from: a single log-uniform lr.

Errors

Error::InvalidSpace if the range is degenerate (it never is for a well-formed problem).

Trait Implementations

impl Clone for ScheduleProblem

fn clone(&self) -> ScheduleProblem

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for ScheduleProblem

impl Debug for ScheduleProblem

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ScheduleProblem

fn default() -> Self

The tuned default the oracle uses (see the module docs).

impl PartialEq for ScheduleProblem

fn eq(&self, other: &ScheduleProblem) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ScheduleProblem