Struct DqnAgent 

pub struct DqnAgent<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 */ }

A DQN agent.

Implements ε-greedy action selection, experience replay, and TD learning with a target network. Generic over:

• E: the environment type (must satisfy rl_traits::Environment)
• Enc: the observation encoder (converts E::Observation to tensors)
• Act: the action mapper (converts E::Action to/from integer indices)
• B: the Burn backend (e.g. NdArray, Wgpu)
• Buf: the replay buffer (defaults to CircularBuffer – swap for PER etc.)

Implementations

impl<E, Enc, Act, B> DqnAgent<E, Enc, Act, B>

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,

pub fn new( encoder: Enc, action_mapper: Act, config: DqnConfig, device: B::Device, seed: u64, ) -> Self

Create a new agent using the default CircularBuffer replay buffer.

impl<E, Enc, Act, B, Buf> DqnAgent<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_with_buffer( encoder: Enc, action_mapper: Act, config: DqnConfig, device: B::Device, seed: u64, buffer: Buf, ) -> Self

Create a new agent with a custom replay buffer.

pub fn epsilon(&self) -> f64

The current exploration probability.

pub fn set_total_steps(&mut self, steps: usize)

Override the internal step counter (use when resuming training).

pub fn into_policy(self) -> DqnPolicy<E, Enc, Act, B::InnerBackend>

Convert this trained agent into an inference-only DqnPolicy.

Trait Implementations

impl<E, Enc, Act, B, Buf> Checkpointable for DqnAgent<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>,

fn save(&self, path: &Path) -> Result<()>

Save weights to path (without extension – implementations add their own).

fn load(self, path: &Path) -> Result<Self>

Load weights from path, consuming and returning self.

impl<E, Enc, Act, B, Buf> LearningAgent<E> for DqnAgent<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>,

fn act(&mut self, obs: &E::Observation, mode: ActMode) -> E::Action

Select an action for obs according to mode.

fn observe(&mut self, experience: Experience<E::Observation, E::Action>)

Record a transition and update the agent’s internal state.

fn total_steps(&self) -> usize

Total number of observe calls since construction.

fn episode_extras(&self) -> HashMap<String, f64>

Per-episode aggregates of step-level values, reported at episode end.

fn on_episode_start(&mut self)

Called by crate::training::TrainingSession at the start of each episode so the agent can reset its per-episode aggregators.

impl<E, Enc, Act, B, Buf> Policy<<E as Environment>::Observation, <E as Environment>::Action> for DqnAgent<E, Enc, Act, B, Buf>

where E: Environment, Enc: ObservationEncoder<E::Observation, B::InnerBackend>, Act: DiscreteActionMapper<E::Action>, B: AutodiffBackend, Buf: ReplayBuffer<E::Observation, E::Action>,

fn act(&self, obs: &E::Observation) -> E::Action

Select an action given the current observation.