Struct NeuralOptimizer 

pub struct NeuralOptimizer {
    pub network: OptimizerNetwork,
    pub parameters: Vec<Tensor>,
    pub meta_optimizer: Option<Box<dyn Optimizer>>,
    pub training: bool,
    pub step_count: usize,
}

Neural optimizer that uses a neural network to learn optimization updates

Fields

network: OptimizerNetwork

Neural network for computing updates

parameters: Vec<Tensor>

Parameters being optimized

meta_optimizer: Option<Box<dyn Optimizer>>

Meta-optimizer for training the neural optimizer

training: bool

Training mode flag

step_count: usize

Step counter

Implementations

impl NeuralOptimizer

pub fn new( parameters: Vec<Tensor>, config: Option<NeuralOptimizerConfig>, ) -> OptimizerResult<Self>

Create a new neural optimizer

pub fn with_meta_learning( parameters: Vec<Tensor>, config: Option<NeuralOptimizerConfig>, ) -> OptimizerResult<Self>

Create a neural optimizer with meta-learning capabilities

pub fn train(&mut self, mode: bool)

Set training mode for meta-learning

pub fn reset(&mut self)

Reset the neural optimizer state

pub fn compute_meta_loss(&self, target_loss: f32, actual_loss: f32) -> f32

Compute loss for meta-learning (simplified objective)

pub fn meta_step(&mut self, meta_loss: f32) -> OptimizerResult<()>

Update the neural network parameters using meta-gradients

Trait Implementations

impl Optimizer for NeuralOptimizer

fn step(&mut self) -> OptimizerResult<()>

Perform a single optimization step

fn zero_grad(&mut self)

Zero all gradients

fn get_lr(&self) -> Vec<f32>

Get the current learning rate

fn set_lr(&mut self, lr: f32)

Set one learning rate for every parameter group (broadcast).

fn state_dict(&self) -> OptimizerResult<OptimizerState>

Get state dict for serialization

fn add_param_group( &mut self, params: Vec<Arc<RwLock<Tensor>>>, options: HashMap<String, f32>, )

Add a parameter group

fn load_state_dict(&mut self, state: OptimizerState) -> OptimizerResult<()>

Load state dict

fn set_lrs(&mut self, lrs: &[f32])

Set the learning rate of each parameter group individually.

fn parameters(&self) -> Vec<Arc<RwLock<Tensor>>>

Get the parameter tensors managed by this optimizer.