Trait SeqIterative

pub trait SeqIterative {
    type State;

    // Required methods
    fn initial_state(&self) -> Self::State;
    fn step(&self, state: &mut Self::State, input: &Tensor) -> Tensor;

    // Provided methods
    fn iter<I>(&self, inputs: I) -> SeqIterator<&Self, I::IntoIter> 
       where I: IntoIterator,
             I::Item: AsRef<Tensor> { ... }
    fn into_iter<I>(self, inputs: I) -> SeqIterator<Self, I::IntoIter> 
       where I: IntoIterator,
             I::Item: AsRef<Tensor>,
             Self: Sized { ... }
}

An iterative transformation of a sequence of input Tensor.

Required Associated Types

type State

Sequence state managed by the module.

Required Methods

fn initial_state(&self) -> Self::State

Construct an initial state for the start of a new sequence.

fn step(&self, state: &mut Self::State, input: &Tensor) -> Tensor

Transform the next value in the sequence.

Args

• input - The input for one step. A tensor with shape [NUM_INPUT_FEATURES]
• state - The policy hidden state.

Returns

• output - The output tensor. Has shape [NUM_OUT_FEATURES]
• state - A new value for the hidden state.

Provided Methods

fn iter<I>(&self, inputs: I) -> SeqIterator<&Self, I::IntoIter>

where I: IntoIterator, I::Item: AsRef<Tensor>,

Iterate over input tensors

fn into_iter<I>(self, inputs: I) -> SeqIterator<Self, I::IntoIter>

where I: IntoIterator, I::Item: AsRef<Tensor>, Self: Sized,

Convert into an iterator over input tensors.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<M: SeqIterative> SeqIterative for [M]

type State = Vec<<M as SeqIterative>::State>

fn initial_state(&self) -> Self::State

fn step(&self, state: &mut Self::State, input: &Tensor) -> Tensor

impl<M: SeqIterative, const N: usize> SeqIterative for [M; N]

type State = [<M as SeqIterative>::State; N]

fn initial_state(&self) -> Self::State

fn step(&self, state: &mut Self::State, input: &Tensor) -> Tensor

impl<T: SeqIterative + ?Sized> SeqIterative for &T

type State = <T as SeqIterative>::State

fn initial_state(&self) -> Self::State

fn step(&self, state: &mut Self::State, input: &Tensor) -> Tensor

impl<T: SeqIterative + ?Sized> SeqIterative for Box<T>

type State = <T as SeqIterative>::State

fn initial_state(&self) -> Self::State

fn step(&self, state: &mut Self::State, input: &Tensor) -> Tensor

Implementors

impl SeqIterative for Activation

Iterate over a sequence by independently and identically transforming each step.

type State = ()

impl SeqIterative for Linear

Iterate over a sequence by independently and identically transforming each step.

type State = ()

impl SeqIterative for Mlp

Iterate over a sequence by independently and identically transforming each step.

type State = ()

impl<A, B> SeqIterative for Chain<A, B>

where A: SeqIterative, B: SeqIterative,

type State = (<A as SeqIterative>::State, <B as SeqIterative>::State)

impl<T, F> SeqIterative for BatchMap<T, F>

where T: SeqIterative, F: Fn(Tensor) -> Tensor,

type State = <T as SeqIterative>::State