Enum LayerLoops 

pub enum LayerLoops {
    Repeat {
        n_phys: usize,
        n_loops: usize,
        skip_loop_final_norm: bool,
    },
    Hrm {
        lps: usize,
        h_cycles: usize,
        l_cycles: usize,
    },
}

A model whose logical layers are several passes over fewer physical ones.

Two shapes, because two graphs upstream do it and they differ in every detail but that: which physical layer a pass runs, what norm sits at a pass boundary, and whether the passes share ONE residual stream (nanbeige) or recombine TWO (hrm_text). Parameterising one enum rather than adding a second field for each difference is what keeps the three host bodies asking one question.

Variants

Repeat

nanbeige.cpp:6-31: n_loops passes over n_phys layers, one residual stream, output_norm between passes.

Fields

n_phys: usize

Physical layers: the blocks the file holds tensors for.

n_loops: usize

Passes over them; >= 2.

skip_loop_final_norm: bool

{arch}.skip_loop_final_norm: no norm between passes.

Hrm

hrm-text.cpp:47-87,183-196: TWO stacks of lps layers each – the file holds 2 * lps blocks – replayed over h_cycles * (l_cycles + 1) passes, with a weightless norm after every pass and the two residual streams recombined at every stack boundary.

Fields

lps: usize

{arch}.hrm.layers_per_stack.

h_cycles: usize

{arch}.hrm.h_cycles.

l_cycles: usize

{arch}.hrm.l_cycles.

Implementations

impl LayerLoops

pub fn logical_layers(&self) -> usize

llama.cpp’s n_layer_all, the count every per-layer thing – the KV caches above all – is sized by.

pub fn physical(&self, l: usize) -> usize

The physical layer logical layer l runs.

pub fn physical_layers(&self) -> usize

Physical layers: how many blocks the file holds tensors for.

pub fn loop_norm_after(&self, l: usize) -> Option<LoopNorm>

The norm applied to the residual AFTER logical layer l, if any.

nanbeige norms at the end of every pass but the LAST (its own output_norm follows that one anyway) and only when the file does not skip it; hrm_text norms at the end of EVERY stack, including the last, because it has no other final norm.

pub fn stack_starts_at(&self, l: usize) -> bool

Does logical layer l START a stack, i.e. does the residual it reads come from recombining the two streams?

pub fn stream_after(&self, l: usize) -> Option<HrmStream>

Which stream the pass ending at logical layer l writes, or None when l does not end a stack.

Trait Implementations

impl Clone for LayerLoops

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for LayerLoops

impl Debug for LayerLoops

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

Formats the value using the given formatter.

impl Eq for LayerLoops

impl PartialEq for LayerLoops

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for LayerLoops