Struct NeuralEngine 

pub struct NeuralEngine<T = f32> { /* private fields */ }

A Neural Turing Machine (NTM) is a type of recurrent neural network that can learn to perform algorithmic tasks by interacting with an external memory. The NTM consists of a controller network that interacts with a memory matrix using attention mechanisms. Internally, the controller is a shallow feed-forward neural network capable of processing encoded inputs and producing outputs that determine the next state, symbol, and direction of the machine.

Implementations

impl<T> NeuralEngine<T>

pub const STATES: usize = 2usize

pub const SYMBOLS: usize = 3usize

pub fn new(alphabet: [usize; 3], _: State<usize>) -> NeuralEngine<T>

where T: Clone + Default + FromPrimitive,

pub const fn alphabet(&self) -> &[usize; 3]

returns an immutable reference to the alphabet

pub const fn controller(&self) -> &NeuralController<T>

returns an immutable reference to the controller

pub fn controller_mut(&mut self) -> &mut NeuralController<T>

returns a mutable reference to the controller

pub const fn features(&self) -> NeuralFeatures

returns a copy of the engine controller’s features

pub fn features_mut(&mut self) -> &mut NeuralFeatures

returns a mutable reference to the engine controller’s features

pub const fn memory(&self) -> &ArrayBase<OwnedRepr<T>, Dim<[usize; 2]>>

returns an immutable reference to the memory of the machine

pub fn memory_mut(&mut self) -> &mut ArrayBase<OwnedRepr<T>, Dim<[usize; 2]>>

returns a mutable reference to the memory of the machine

pub const fn position(&self) -> usize

returns the current position of the head of the machine

pub fn position_mut(&mut self) -> &mut usize

returns a mutable reference to the position of the head of the machine

pub const fn state(&self) -> State<usize>

returns a copy of the state of the machine

pub fn state_mut(&mut self) -> &mut State<usize>

returns a mutable reference to the state of the machine

pub const fn tape(&self) -> &Vec<usize>

returns an immutable reference to the tape of the machine

pub fn tape_mut(&mut self) -> &mut Vec<usize>

returns a mutable reference to the tape of the machine

pub fn set_position(&mut self, position: usize)

set the current position of the machine

pub fn set_state(&mut self, state: State<usize>)

set the state of the machine

pub fn set_tape<I>(&mut self, iter: I)

where I: IntoIterator<Item = usize>,

set the tape of the machine

pub fn head(&self) -> Head<usize, usize>

returns the head of the machine

pub fn init(self) -> NeuralEngine<T>

where T: Float + FromPrimitive + SampleUniform, StandardNormal: Distribution<T>,

inititalize the controller and return a new instance with the randomized parameters

pub fn reset(&mut self)

clear’s the contents of the tape and resets the position of the head back to 0

pub fn reset_position(&mut self)

reset the position of the head of the machine to 0

impl<T> NeuralEngine<T>

where T: Float + FromPrimitive + ScalarOperand, NeuralEngine<T>: ComputationalEngine<usize, [usize; 3], Store = Vec<usize>>,

pub fn adapt_to_target( &mut self, tail: Tail<usize, usize>, ) -> Result<(), ActorError>

where T: NumAssign + Sum,

adapt the engine’s weights to the target tail (pattern)

pub fn decode_outputs_into_tail( &self, output: ArrayBase<OwnedRepr<T>, Dim<[usize; 1]>>, ) -> Tail<usize, usize>

extract a tail (next_state, next_symbol, direction) from controller output

pub fn determine_best_direction(&self, expected: usize) -> Direction

determine the best direction toDetermine best direction to reach expected symbol based on current state and tape

pub fn encode_input_symbol( &self, symbol: usize, ) -> ArrayBase<OwnedRepr<T>, Dim<[usize; 1]>>

Prepares the input for the controller network by combining state and symbol information

pub fn execute_with_stored( &mut self, memory: &TopoLedger<T>, ) -> Result<(), ActorError>

where T: NumAssign + Sum,

Execute the NTM using learned rules from topological memory

pub fn forward( &self, input: &ArrayBase<OwnedRepr<T>, Dim<[usize; 1]>>, ) -> Result<ArrayBase<OwnedRepr<T>, Dim<[usize; 1]>>, Error>

forward input through the controller

pub fn learn_sequence<U, V>( &mut self, inputs: &ArrayBase<U, Dim<[usize; 1]>>, targets: &ArrayBase<V, Dim<[usize; 1]>>, ) -> Result<T, ActorError>

where U: Data<Elem = usize>, V: Data<Elem = usize>, T: NumAssign + Sum, NeuralEngine<T>: ComputationalEngine<usize, [usize; 3], Store = Vec<usize>>,

train the model to learn the given dataset for a number of epochs

pub fn learn_sequence_for<U, V>( &mut self, inputs: &ArrayBase<U, Dim<[usize; 1]>>, targets: &ArrayBase<V, Dim<[usize; 1]>>, epochs: usize, ) -> Result<T, ActorError>

where U: Data<Elem = usize>, V: Data<Elem = usize>, T: NumAssign + Sum,

train the model to learn the given dataset for a number of epochs

pub fn predict_sequence(&mut self, n: usize) -> Vec<usize>

Predict the next n symbols in the sequence

pub fn learn_sequences_for<U, V>( &mut self, inputs: &ArrayBase<U, Dim<[usize; 2]>>, targets: &ArrayBase<V, Dim<[usize; 2]>>, epochs: usize, ) -> Result<T, ActorError>

where U: Data<Elem = usize>, V: Data<Elem = usize>, T: NumAssign + Sum,

train the engine on a sequence of inputs with their expected targets

pub fn read_memory(&self) -> ArrayBase<OwnedRepr<T>, Dim<[usize; 1]>>

where ArrayBase<ViewRepr<&'a T>, Dim<[usize; 2]>>: for<'a> Dot<ArrayBase<OwnedRepr<T>, Dim<[usize; 1]>>, Output = ArrayBase<OwnedRepr<T>, Dim<[usize; 1]>>>,

read from memory using attention mechanism

pub fn step(&mut self) -> Result<(), ActorError>

Perform a single step of the Turing machine

pub fn update_attention( &mut self, inputs: ArrayBase<OwnedRepr<T>, Dim<[usize; 1]>>, )

update the attention mechanism using controller output

pub fn write_memory( &mut self, erase: &ArrayBase<OwnedRepr<T>, Dim<[usize; 1]>>, add: &ArrayBase<OwnedRepr<T>, Dim<[usize; 1]>>, )

write to memory using attention mechanism

Trait Implementations

impl<T> Clone for NeuralEngine<T>

where T: Clone,

fn clone(&self) -> NeuralEngine<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> ComputationalEngine<usize, [usize; 3]> for NeuralEngine<T>

where T: Default + Float + FromPrimitive + ScalarOperand + Send + Sync + Debug,

fn new(alphabet: [usize; 3], initial_state: State<usize>) -> NeuralEngine<T>

fn alphabet(&self) -> &[usize; 3]

returns an immutable reference to the alphabet

fn alphabet_mut(&mut self) -> &mut [usize; 3]

returns a mutable reference to the alphabet

fn head(&self) -> Head<&usize, &usize>

returns an instance of the head with immutable references to the state and symbol

fn head_mut(&mut self) -> Head<&mut usize, &mut usize>

returns an instance of the head with mutable references to the state and symbol

fn position(&self) -> usize

returns a copy of the machine’s current position

fn position_mut(&mut self) -> &mut usize

returns a mutable reference to the machine’s current position

fn state(&self) -> State<&usize>

returns an instance of the state with an immutable inner value

fn state_mut(&mut self) -> State<&mut usize>

returns an instance of the state with a mutable inner value

fn tape(&self) -> &Vec<usize>

returns an immutable reference to the tape

fn tape_mut(&mut self) -> &mut Vec<usize>

returns a mutable reference to the tape

fn step(&mut self) -> Result<(), ActorError>

preform a single step of the turing machine

fn set_alphabet(&mut self, alphabet: [usize; 3])

sets the alphabet of the turing machine

fn set_position(&mut self, position: usize)

sets the position of the head

fn set_state(&mut self, state: State<usize>)

sets the state of the head

fn set_tape<I>(&mut self, tape: I)

where I: IntoIterator<Item = usize>,

sets the tape of the turing machine

fn restore_from_snapshot(&mut self, snapshot: SnapshotBase<Q, S, Self::Store>)

where Self::Store: IntoIterator<Item = <S as RawStore>::Elem>,

restores the engine from a snapshot

fn snapshot(&self) -> SnapshotBase<&Q, &S, &Self::Store>

returns a snapshot of the engine

impl<T> Debug for NeuralEngine<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for NeuralEngine<T>

where T: Clone + Default + FromPrimitive,

fn default() -> NeuralEngine<T>

Returns the “default value” for a type.

impl<T> RawEngine for NeuralEngine<T>

where T: Send + Sync + Debug,

type Store = Vec<usize>

impl<T> Engine for NeuralEngine<T>

where T: Clone + Default + Send + Sync + Debug + FromPrimitive,