Struct RecurrentPassSpec 

pub struct RecurrentPassSpec {
    pub loop_start: usize,
    pub loop_end: usize,
    pub feedback: Vec<RecurrentFeedbackEntry>,
    pub sustained: bool,
    pub depth: usize,
}

Specification for a recurrent multi-pass forward through a layer block.

The recurrence re-runs layers loop_start..=loop_end a total of depth times, with optional feedback injected into the hidden state between passes.

Without feedback

Each subsequent pass receives the previous pass’s output (true recurrence — extra depth).

With feedback

Each subsequent pass resets to the saved pre-loop hidden state plus feedback vectors: hidden[position] += strength * vector. This means every recurrent pass sees the same clean input with the nudge applied — the layers process H₀ + nudge rather than iterating on their own output, which would cause degeneration.

Fields

loop_start: usize

First layer of the recurrent block (inclusive).

loop_end: usize

Last layer of the recurrent block (inclusive).

feedback: Vec<RecurrentFeedbackEntry>

Feedback vectors to inject between passes.

When present, each recurrent pass resets to the saved pre-loop state and injects these vectors before re-running the loop layers. If empty, each pass receives the previous pass’s output unmodified (pure depth increase).

sustained: bool

If true, also inject feedback at the current last token position during each autoregressive generation step (sustained recurrence).

If false, feedback is only injected at the original prompt positions (prefill-only recurrence).

depth: usize

Number of times to run the recurrent layer block.

Must be at least 1 (a single pass, no recurrence). The default is 2 (one initial pass plus one recurrent pass with feedback injection).

Implementations

impl RecurrentPassSpec

pub const fn no_feedback(loop_start: usize, loop_end: usize) -> Self

Create a spec with no feedback (pure double-pass, depth 2).

pub const fn with_sustained(self, sustained: bool) -> Self

Set the sustained flag (builder pattern).

pub const fn with_depth(self, depth: usize) -> Self

Set the recurrence depth (builder pattern).

depth is the total number of times the recurrent layer block is executed. The default is 2 (one initial pass plus one recurrent pass). A depth of 1 means no recurrence (single pass).

pub fn add_feedback(&mut self, position: usize, vector: Tensor, strength: f32)

Add a feedback entry.

pub fn validate( &self, n_layers: usize, seq_len: usize, d_model: usize, ) -> Result<()>

Validate the spec against model dimensions.

Errors

Returns MIError::Intervention if the layer range is invalid, feedback positions exceed sequence length, or feedback vectors have the wrong dimension.

Trait Implementations

impl Clone for RecurrentPassSpec

fn clone(&self) -> RecurrentPassSpec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RecurrentPassSpec

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

Formats the value using the given formatter.