Struct LatentNetwork 

pub struct LatentNetwork<M: Module> {
    pub in_proj: Linear,
    pub layers: Layers<M>,
    pub out_proj: Linear,
    pub class_tokens: Vec<ClassToken>,
    pub class_tokens_emb: Option<Param<Tensor<2>>>,
}

A feature/regression network on latents: in_proj (input_size → d_model) → Layers<M> → out_proj (d_model → output_size).

Fields

in_proj: Linear

Linear projection input_size → d_model.

layers: Layers<M>

The shared Mamba-x layer stack.

out_proj: Linear

Linear projection d_model → output_size.

class_tokens: Vec<ClassToken>

Positions of the network’s class tokens, spliced into the input sequence (at input_size width) before in_proj. Empty ⇒ none.

class_tokens_emb: Option<Param<Tensor<2>>>

The class-token embeddings, [num_class_tokens, input_size].

Implementations

impl<M: MambaBlock> LatentNetwork<M>

where M::SsdPath: Clone,

pub fn class_token_output_indices(&self, orig_len: usize) -> Vec<usize>

Output positions of the class tokens for an orig_len input.

fn insert_tokens(&self, x: Tensor<3>) -> Tensor<3>

Splice this network’s class latents into x (no-op when there are none).

pub fn forward( &self, x: Tensor<3>, caches: Option<M::Caches>, ssd_path: M::SsdPath, ) -> (Tensor<3>, M::Caches)

in_proj → layers → out_proj over a full sequence ([batch, sequence, input_size] → [batch, sequence (+ class tokens), output_size]).

pub fn step( &self, x: Tensor<2>, caches: Option<M::Caches>, own_index: Option<&mut usize>, layers_own_index: Option<&mut usize>, layer_indices: Option<&mut Vec<usize>>, ) -> (Tensor<2>, M::Caches)

Single-token step ([batch, input_size] → [batch, output_size]).

Three independent class cursors:

• own_index — the network’s own Self::class_tokens (spliced before in_proj). When it lands on a class-token position those tokens are stepped first (each a full network pass, advancing own_index), then the user token; only the user token’s output is returned.
• layers_own_index / layer_indices — forwarded straight to the inner Layers::step (stack-level latents, and the per-virtual-layer cursor vector respectively).

As in forward, the network’s class tokens are part of the sequence that enters the layers, so each is threaded through the layers (carrying the inner cursors) just like the user token — only the user token’s output is returned. A None cursor skips that level; Middle/End markers panic for the cursored level (use forward).

pub fn step_infinite(&self, x: Tensor<2>) -> Tensor<2>

Stationary fixed point of the network under a constant input token: in_proj → Layers::step_infinite → out_proj, no caches. Cursorless (class tokens are not injected).

pub fn step_n_approx( &self, x: Tensor<2>, n: usize, caches: Option<M::Caches>, ) -> (Tensor<2>, M::Caches)

Approximate jump of n consecutive cursorless Self::step calls on the same constant token — see Layers::step_n_approx for the approximation contract.

Trait Implementations

impl<M> AutodiffModule for LatentNetwork<M>

where M: AutodiffModule + ModuleDisplay + Module,

fn valid(&self) -> Self

Returns the same module, but on the inner backend without auto-differentiation.

fn from_inner(module: Self) -> Self

Wraps an inner module back into an auto-diff module.

impl<M> Clone for LatentNetwork<M>

where M: Module + ModuleDisplay + Module,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M: Debug + Module> Debug for LatentNetwork<M>

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

Formats the value using the given formatter.

impl<M> Display for LatentNetwork<M>

where M: Module + ModuleDisplay + Module,

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

Formats the value using the given formatter.

impl<M> Module for LatentNetwork<M>

where M: Module + ModuleDisplay + Module,

type Record = LatentNetworkRecord<M>

Type to save and load the module.

fn load_record(self, record: Self::Record) -> Self

Load the module state from a record.

fn into_record(self) -> Self::Record

Convert the module into a record containing the state.

fn num_params(&self) -> usize

Get the number of parameters the module has, including all of its sub-modules.

fn visit<Visitor: ModuleVisitor>(&self, visitor: &mut Visitor)

Visit each tensor parameter in the module with a visitor.

fn map<Mapper: ModuleMapper>(self, mapper: &mut Mapper) -> Self

Map each tensor parameter in the module with a mapper.

fn collect_devices(&self, devices: Devices) -> Devices

Return all the devices found in the underneath module tree added to the given vector without duplicates.

fn to_device(self, device: &Device) -> Self

Move the module and all of its sub-modules to the given device.

fn fork(self, device: &Device) -> Self

Fork the module and all of its sub-modules to the given device.

fn devices(&self) -> Vec<Device>

Return all the devices found in the underneath module tree without duplicates.

fn no_grad(self) -> Self

Each tensor in the module tree will not require grad.

fn train(self) -> Self

where Self: AutodiffModule,

Move the module and all of its sub-modules to the autodiff backend.

fn quantize_weights(self, quantizer: &mut Quantizer) -> Self

Quantize the weights of the module.

impl<M> ModuleDisplay for LatentNetwork<M>

where M: Module + ModuleDisplay + Module,

fn format(&self, passed_settings: DisplaySettings) -> String

Formats the module with provided display settings.

fn custom_settings(&self) -> Option<DisplaySettings>

Custom display settings for the module.

fn custom_content(&self, _content: Content) -> Option<Content>

Custom attributes for the module.

impl<M> ModuleDisplayDefault for LatentNetwork<M>

where M: Module + ModuleDisplay + Module,

fn content(&self, content: Content) -> Option<Content>

Attributes of the module used for display purposes.

fn num_params(&self) -> usize

Gets the number of the parameters of the module.