Struct NtmOptimizer 

pub struct NtmOptimizer<A: Float + ScalarOperand + Debug> { /* private fields */ }

Memory-augmented NTM-style optimizer.

NtmOptimizer keeps an N × W memory matrix between calls to Optimizer::step. On each step it constructs a query key from the gradient, attends to the memory via content-based (cosine similarity) addressing, optionally fuses the result with a shifted copy of the previous attention, reads a vector from memory, writes the new key back via the NTM erase/add rule, and finally combines the read vector with the raw gradient to produce the parameter update.

See the module-level documentation for the full algorithm.

Examples

use scirs2_core::ndarray::Array1;
use optirs_core::optimizers::{NtmOptimizer, Optimizer};

let mut opt: NtmOptimizer<f64> = NtmOptimizer::new(8, 4, 0.01);
let params = Array1::from_vec(vec![1.0, -1.0, 0.5, 0.0]);
let grads = Array1::from_vec(vec![0.2, -0.2, 0.1, 0.0]);
let next = opt.step(&params, &grads).expect("ntm step");
assert_eq!(next.len(), 4);

Implementations

impl<A: Float + ScalarOperand + Debug> NtmOptimizer<A>

pub fn new(memory_slots: usize, memory_width: usize, learning_rate: A) -> Self

Constructs an NtmOptimizer with default hyperparameters and the supplied memory shape and learning rate.

The memory matrix is initialised to all zeros, as are the previous attention vectors. The RNG seed defaults to 42 (mirroring the default NtmConfig).

pub fn with_config(config: NtmConfig<A>) -> Self

Constructs an NtmOptimizer from a fully populated NtmConfig.

The memory matrix is initialised to zero. A seeded RNG is allocated (and immediately dropped) so a downstream caller that adds a stochastic initialisation strategy in the future does not need to change the public constructor signature.

pub fn with_read_sharpness(self, beta: A) -> Self

Sets the read-attention sharpness factor β.

pub fn with_erase_gate(self, gate: A) -> Self

Sets the erase-gate scalar (intended to live in [0, 1]).

pub fn with_addressing(self, mode: AddressingMode) -> Self

Selects the addressing mode for the read head.

pub fn with_memory_weight(self, weight: A) -> Self

Sets the weight applied to the (tiled) read vector in the final update.

pub fn with_gradient_weight(self, weight: A) -> Self

Sets the weight applied to the raw gradient in the final update.

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

Overrides the RNG seed (and rebuilds the internal RNG).

pub fn config(&self) -> &NtmConfig<A>

Returns the current configuration.

pub fn memory(&self) -> &Array2<A>

Read-only access to the memory matrix.

pub fn memory_mut(&mut self) -> &mut Array2<A>

Mutable access to the memory matrix. Intended primarily for tests that need to seed memory contents directly.

pub fn last_read_weights(&self) -> &Array1<A>

Returns the read attention vector emitted by the most recent step.

pub fn last_write_weights(&self) -> &Array1<A>

Returns the write attention vector emitted by the most recent step.

pub fn step_count(&self) -> usize

Returns the number of Optimizer::step calls completed so far.

pub fn reset(&mut self)

Resets the optimizer to its post-construction state: memory and previous attentions become zero and the step counter is cleared.

Trait Implementations

impl<A: Float + ScalarOperand + Debug> Debug for NtmOptimizer<A>

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

Formats the value using the given formatter.

impl<A, D> Optimizer<A, D> for NtmOptimizer<A>

where A: Float + ScalarOperand + Debug, D: Dimension,

fn step( &mut self, params: &Array<A, D>, gradients: &Array<A, D>, ) -> Result<Array<A, D>>

Updates parameters using the given gradients

fn get_learning_rate(&self) -> A

Gets the current learning rate

fn set_learning_rate(&mut self, learning_rate: A)

Sets a new learning rate

fn step_list( &mut self, params_list: &[&Array<A, D>], gradients_list: &[&Array<A, D>], ) -> Result<Vec<Array<A, D>>>

Updates multiple parameter arrays at once