Struct SacConfig 

pub struct SacConfig {

    pub actor_lr: f64,
    pub critic_lr: f64,
    pub alpha_lr: f64,
    pub gamma: f64,
    pub tau: f64,
    pub batch_size: usize,
    pub buffer_capacity: usize,
    pub min_buffer_size: usize,
    pub learning_starts: usize,
    pub gradient_steps_per_env_step: usize,
    pub hidden_dim: usize,
    pub num_hidden_layers: usize,
    pub auto_alpha: bool,
    pub init_alpha: f32,
    pub target_entropy: Option<f32>,
    pub max_grad_norm: Option<f64>,
    pub seed: u64,
}

SAC configuration parameters.

Default values target classic Pendulum-scale continuous control: 1M-capacity replay, 256-sample batches, always-soft Polyak target updates (tau = 0.005), automatic entropy temperature tuning, and the 3e-4 Adam learning rate the v2 paper uses for all three optimizers. Smoke tests typically override buffer_capacity down to ~50k.

Fields

actor_lr: f64

Adam learning rate for the stochastic actor.

critic_lr: f64

Adam learning rate for both online critics (q1, q2).

alpha_lr: f64

Adam learning rate for the entropy temperature log_alpha. Only used when Self::auto_alpha is true.

gamma: f64

Discount factor used in the critic TD target.

tau: f64

Polyak (soft) target update coefficient tau. SAC always performs a soft update of both target critics every gradient step: theta_target <- tau * theta_online + (1 - tau) * theta_target.

batch_size: usize

Number of transitions sampled per gradient update.

buffer_capacity: usize

Maximum number of transitions stored in the replay buffer. Older transitions are evicted FIFO once capacity is reached.

min_buffer_size: usize

Minimum number of transitions required before the first gradient update. Until the buffer holds this many transitions the trainer only collects experience.

learning_starts: usize

Number of environment steps for which actions are drawn uniformly at random (pure exploration) before the actor starts choosing actions.

gradient_steps_per_env_step: usize

Number of gradient updates performed per environment step (the update-to-data ratio).

hidden_dim: usize

Width of every hidden layer in the actor and critics.

num_hidden_layers: usize

Number of hidden layers in the actor and critic trunks.

auto_alpha: bool

Automatically tune the entropy temperature alpha (Haarnoja et al. 2018 v2). When true, log_alpha is optimized to drive the policy entropy toward Self::target_entropy. When false, alpha is held fixed at Self::init_alpha.

init_alpha: f32

Initial entropy temperature alpha. When Self::auto_alpha is false this is the fixed value used throughout training; when true it is the starting point (log_alpha = ln(init_alpha)).

target_entropy: Option<f32>

Target policy entropy for automatic temperature tuning. None resolves to the conventional heuristic -action_dim at trainer construction time.

max_grad_norm: Option<f64>

Optional global gradient-norm clip applied to every optimizer step. None (the SAC default) leaves the updates unclipped.

seed: u64

Seed threaded through replay sampling, actor noise sampling, and seeded network init for bit-exact reproducibility.

Implementations

impl SacConfig

pub fn new() -> Self

Create a new default configuration.

pub fn validate(&self) -> Result<()>

Validate configuration parameters.

Returns an Err describing the first invalid field encountered.

pub fn resolved_target_entropy(&self, action_dim: usize) -> f32

Resolve the effective target entropy for automatic temperature tuning, applying the -action_dim heuristic when Self::target_entropy is None.

pub fn actor_lr(self, lr: f64) -> Self

Set the actor learning rate.

pub fn critic_lr(self, lr: f64) -> Self

Set the critic learning rate (applied to both online critics).

pub fn alpha_lr(self, lr: f64) -> Self

Set the entropy-temperature learning rate.

pub fn gamma(self, gamma: f64) -> Self

Set the discount factor gamma.

pub fn tau(self, tau: f64) -> Self

Set the Polyak soft-update coefficient tau.

pub fn batch_size(self, size: usize) -> Self

Set the minibatch size.

pub fn buffer_capacity(self, capacity: usize) -> Self

Set the replay buffer capacity.

pub fn min_buffer_size(self, size: usize) -> Self

Set the minimum buffer size before the first gradient update.

pub fn learning_starts(self, steps: usize) -> Self

Set the number of random-action warmup steps.

pub fn gradient_steps_per_env_step(self, steps: usize) -> Self

Set the number of gradient updates per environment step.

pub fn hidden_dim(self, dim: usize) -> Self

Set the hidden-layer width for the actor and critics.

pub fn num_hidden_layers(self, layers: usize) -> Self

Set the number of hidden layers for the actor and critics.

pub fn auto_alpha(self, enabled: bool) -> Self

Enable or disable automatic entropy-temperature tuning.

pub fn init_alpha(self, alpha: f32) -> Self

Set the initial (or fixed) entropy temperature alpha.

pub fn target_entropy(self, entropy: f32) -> Self

Set an explicit target entropy, overriding the -action_dim heuristic.

pub fn max_grad_norm(self, norm: f64) -> Self

Enable global gradient-norm clipping with the given cap.

pub fn seed(self, seed: u64) -> Self

Set the reproducibility seed.

Trait Implementations

impl Clone for SacConfig

fn clone(&self) -> SacConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SacConfig

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

Formats the value using the given formatter.

impl Default for SacConfig

fn default() -> Self

Returns the “default value” for a type.