Enum Job 

pub enum Job {
    Embed {
        tensor: usize,
    },
    Matvec {
        tensor: usize,
        from: Slot,
        to: Slot,
        fold: Fold,
    },
    Vector(VectorJob),
    Delta {
        layer: usize,
        query: Slot,
        key: Slot,
        value: Slot,
        value_at: usize,
        log_decay: Slot,
        decay: Slot,
        gate: Slot,
        to: Slot,
        norm: Option<DeltaNorm>,
    },
    Attend {
        layer: usize,
        query: Slot,
        heads: usize,
        scale: f32,
        to: Slot,
    },
    Advance,
}

One job of the sequencer.

Variants

Embed

Each row’s Slot::Residual its token’s row of tensor tensor, dequantized.

Fields

tensor: usize

Matvec

The array: tensor tensor times each row of from, each sum folded into its element of to by fold.

Fields

tensor: usize

from: Slot

to: Slot

fold: Fold

Vector(VectorJob)

Delta

The recurrence unit: layer layer’s memory through each row, each sequence’s rows in order, its read-outs gated and normed by norm when it has one.

Fields

layer: usize

query: Slot

key: Slot

value: Slot

value_at: usize

log_decay: Slot

decay: Slot

gate: Slot

to: Slot

norm: Option<DeltaNorm>

Attend

The attention unit: each row’s heads query heads over layer layer’s cache of its sequence.

Fields

layer: usize

query: Slot

heads: usize

scale: f32

to: Slot

Advance

Every sequence the step advances moves past its rows.

Implementations

impl Job

pub fn reads(&self) -> Vec<Slot>

The store slots the job reads, each once.

pub fn writes(&self) -> (Vec<Slot>, Vec<Slot>)

The store slots the job writes: those it makes afresh, whole, and those it writes in part, the rest of each as the job found it.

Trait Implementations

impl Clone for Job

fn clone(&self) -> Job

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Job

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

Formats the value using the given formatter.

impl PartialEq for Job

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Job