Struct DqnTrainer 

pub struct DqnTrainer<E, Enc, Act, B, Buf = CircularBuffer<<E as Environment>::Observation, <E as Environment>::Action>>
where
    E: Environment,
    B: AutodiffBackend,
    Buf: ReplayBuffer<E::Observation, E::Action>,
{ /* private fields */ }

The imperative training driver.

Drives the interaction between an environment and a DQN agent, exposing it as an iterator that yields StepMetrics after every step, as well as higher-level train() and eval() methods.

Usage — iterator style (manual control)

let mut trainer = DqnTrainer::new(env, agent, seed);

for step in trainer.steps().take(50_000) {
    if step.episode_done {
        println!("Episode {} reward: {}", step.episode, step.episode_reward);
    }
}

Usage — imperative style (with TrainingRun)

let run = TrainingRun::create("cartpole", "v1")?;
let mut trainer = DqnTrainer::new(env, agent, seed).with_run(run);
trainer.train(200_000);
let report = trainer.eval(20);
report.print();

Implementations

impl<E, Enc, Act, B, Buf> DqnTrainer<E, Enc, Act, B, Buf>

where E: Environment, E::Observation: Clone + Send + Sync + 'static, E::Action: Clone + Send + Sync + 'static, Enc: ObservationEncoder<E::Observation, B> + ObservationEncoder<E::Observation, B::InnerBackend>, Act: DiscreteActionMapper<E::Action>, B: AutodiffBackend, Buf: ReplayBuffer<E::Observation, E::Action>,

pub fn new(env: E, agent: DqnAgent<E, Enc, Act, B, Buf>, seed: u64) -> Self

pub fn with_run(self, run: TrainingRun) -> Self

Attach a TrainingRun for checkpoint saving and stats persistence.

pub fn with_checkpoint_freq(self, freq: usize) -> Self

How often (in steps) to save a numbered checkpoint. Default: 10_000.

pub fn with_keep_checkpoints(self, keep: usize) -> Self

How many numbered checkpoints to keep on disk. Default: 5.

pub fn with_stats(self, stats: StatsTracker) -> Self

Replace the default stats tracker with a custom one.

pub fn steps(&mut self) -> TrainIter<'_, E, Enc, Act, B, Buf>

Returns an iterator that yields StepMetrics after each environment step.

The iterator is infinite — stop it with .take(n) or break.

pub fn agent(&self) -> &DqnAgent<E, Enc, Act, B, Buf>

Access the agent for evaluation or inspection.

pub fn into_agent(self) -> DqnAgent<E, Enc, Act, B, Buf>

Consume the trainer and return the inner agent.

Useful for converting to a DqnPolicy after training:

let policy = trainer.into_agent().into_policy();

pub fn env(&self) -> &E

Access the environment directly.

pub fn train(&mut self, n_steps: usize)

Run n_steps of training.

If a TrainingRun is attached, saves checkpoints at checkpoint_freq intervals and writes episode records to train_episodes.jsonl.

pub fn eval(&mut self, n_episodes: usize) -> EvalReport

Run n_episodes of greedy evaluation and return an EvalReport.

Exploration is disabled (ε = 0). If a TrainingRun is attached, each episode record is written to eval_episodes.jsonl. If the mean reward improves, saves a best.mpk checkpoint.