🥮 mooncakes.io
    Sign in

    mizchi/webnn/model does not have a README file

    AttentionMask

    source
    pub struct AttentionMask {
      shape_ : 
    Shape
      values_ : Array[Float]
    }

    Materializable additive attention-mask data.

    The shape is [1, tokens, tokens] so it broadcasts across attention heads. Allowed score positions contain zero and masked positions contain the caller-provided negative value.

    AttentionMask::additive

    source

    AttentionMask::batched_causal_padding

    source
    fn AttentionMask::batched_causal_padding(valid_batches : Array[Array[Bool]], masked_value : Float) -> AttentionMask raise 
    TensorError

    AttentionMask::batched_padding

    source
    fn AttentionMask::batched_padding(valid_batches : Array[Array[Bool]], masked_value : Float) -> AttentionMask raise 
    TensorError

    AttentionMask::causal

    source
    fn AttentionMask::causal(tokens : Int, masked_value : Float) -> AttentionMask raise 
    TensorError

    AttentionMask::causal_padding

    source
    fn AttentionMask::causal_padding(valid_tokens : Array[Bool], masked_value : Float) -> AttentionMask raise 
    TensorError

    AttentionMask::padding

    source
    fn AttentionMask::padding(valid_tokens : Array[Bool], masked_value : Float) -> AttentionMask raise 
    TensorError

    AttentionMask::shape

    source

    AttentionMask::values

    source
    fn AttentionMask::values(self : AttentionMask) -> Array[Float]

    BertEncoderBlock

    source
    pub(all) struct BertEncoderBlock[T] {
      attention : SelfAttention[T]
      attention_output_normalization : LayerNorm[T]
      feed_forward : FeedForward[T]
      output_normalization : LayerNorm[T]
    }

    A BERT encoder layer using the original post-normalization order.

    Dropout is intentionally absent because this model represents inference. SelfAttention and FeedForward remain reusable pure sublayers; this block owns the residual and LayerNorm boundaries required by BERT checkpoints.

    BertEncoderBlock::forward

    source
    fn[T : 
    TensorOps    ] BertEncoderBlock::forward(self : BertEncoderBlock[T], input : T) -> T raise

    BertEncoderConfig

    source
    pub struct BertEncoderConfig {
      encoder_ : TransformerEncoderConfig
      layers_ : Int
    }

    Shape and numerical configuration for an inference-only BERT encoder.

    BertEncoderConfig::encoder

    source

    BertEncoderConfig::heads

    source
    fn BertEncoderConfig::heads(self : BertEncoderConfig) -> Int

    BertEncoderConfig::intermediate_size

    source
    fn BertEncoderConfig::intermediate_size(self : BertEncoderConfig) -> Int

    BertEncoderConfig::layers

    source
    fn BertEncoderConfig::layers(self : BertEncoderConfig) -> Int

    BertEncoderConfig::new

    source
    fn BertEncoderConfig::new(layers : Int, width : Int, heads : Int, intermediate_size : Int, input_rank : Int, epsilon : Float) -> BertEncoderConfig raise 
    TensorError

    BertEncoderConfig::width

    source
    fn BertEncoderConfig::width(self : BertEncoderConfig) -> Int

    BertEncoderParameters

    source
    pub struct BertEncoderParameters {
      layers_ : Array[TransformerEncoderParameters]
    }

    Owned per-layer parameters for a BERT encoder stack.

    BertEncoderParameters::layers

    source

    BertEncoderParameters::new

    source

    BertEncoderStack

    source
    pub struct BertEncoderStack[T] {
      layers_ : Array[BertEncoderBlock[T]]
    }

    A non-empty sequence of post-normalization BERT encoder layers.

    BertEncoderStack::forward

    source
    fn[T : 
    TensorOps    ] BertEncoderStack::forward(self : BertEncoderStack[T], input : T) -> T raise

    BertEncoderStack::layer_count

    source
    fn[T] BertEncoderStack::layer_count(self : BertEncoderStack[T]) -> Int

    BertEncoderStack::new

    source

    Conv2dLayer

    source
    pub(all) struct Conv2dLayer[T] {
      weight : T
      bias : T
      options : 
    Conv2dOptions
    }

    Conv2dLayer::forward

    source
    fn[T : 
    TensorOps    ] Conv2dLayer::forward(self : Conv2dLayer[T], input : T) -> T raise

    FeedForward

    source
    pub(all) struct FeedForward[T] {
      input_projection : Linear[T]
      output_projection : Linear[T]
    }

    Position-wise Transformer feed-forward network without normalization or a residual connection. Those concerns belong to TransformerEncoderBlock.

    FeedForward::forward

    source
    fn[T : 
    TensorOps    ] FeedForward::forward(self : FeedForward[T], input : T) -> T raise

    FeedForwardParameters

    source
    pub struct FeedForwardParameters {
      width_ : Int
      hidden_size_ : Int
      input_weight_ : Array[Float]
      input_bias_ : Array[Float]
      output_weight_ : Array[Float]
      output_bias_ : Array[Float]
    }

    FeedForwardParameters::input_bias

    source
    fn FeedForwardParameters::input_bias(self : FeedForwardParameters) -> Array[Float]

    FeedForwardParameters::input_weight

    source
    fn FeedForwardParameters::input_weight(self : FeedForwardParameters) -> Array[Float]

    FeedForwardParameters::matches

    source

    FeedForwardParameters::new

    source
    fn FeedForwardParameters::new(config : TransformerEncoderConfig, input_weight : Array[Float], input_bias : Array[Float], output_weight : Array[Float], output_bias : Array[Float]) -> FeedForwardParameters raise 
    TensorError

    FeedForwardParameters::output_bias

    source
    fn FeedForwardParameters::output_bias(self : FeedForwardParameters) -> Array[Float]

    FeedForwardParameters::output_weight

    source
    fn FeedForwardParameters::output_weight(self : FeedForwardParameters) -> Array[Float]

    LayerNorm

    source
    pub(all) struct LayerNorm[T] {
      scale : T
      bias : T
      axes : Array[Int]
      epsilon : Float
    }

    Layer normalization with explicit axes and epsilon.

    LayerNorm::forward

    source
    fn[T : 
    TensorOps    ] LayerNorm::forward(self : LayerNorm[T], input : T) -> T raise

    Linear

    source
    pub(all) struct Linear[T] {
      weight : T
      bias : T
    }

    Linear::forward

    source
    fn[T : 
    TensorOps    ] Linear::forward(self : Linear[T], input : T) -> T raise

    Mlp

    source
    pub(all) struct Mlp[T] {
      hidden : Linear[T]
      output : Linear[T]
    }

    Mlp::forward

    source
    fn[T : 
    TensorOps    ] Mlp::forward(self : Mlp[T], input : T) -> T raise

    MlpParams

    source
    pub(all) struct MlpParams {
      weight1 : Array[Float]
      bias1 : Array[Float]
      weight2 : Array[Float]
      bias2 : Array[Float]
    }

    SelfAttention

    source
    pub(all) struct SelfAttention[T] {
      query : Linear[T]
      key : Linear[T]
      value : Linear[T]
      output : Linear[T]
      score_scale : T
      additive_mask : T?
      heads : Int
    }

    Fixed-shape self-attention shared by CPU and WebNN backends.

    Input and output use [tokens, width] or [batch, tokens, width]. Internally, projections are reshaped by head; batched matmul computes every batch and head together. This layer returns only the projected attention; residual addition belongs to a Transformer block.

    SelfAttention::forward

    source
    fn[T : 
    TensorOps    ] SelfAttention::forward(self : SelfAttention[T], input : T) -> T raise

    SelfAttentionConfig

    source
    pub struct SelfAttentionConfig {
      width_ : Int
      heads_ : Int
    }

    SelfAttentionConfig::head_size

    source
    fn SelfAttentionConfig::head_size(self : SelfAttentionConfig) -> Int

    SelfAttentionConfig::heads

    source
    fn SelfAttentionConfig::heads(self : SelfAttentionConfig) -> Int

    SelfAttentionConfig::new

    source

    SelfAttentionConfig::score_scale

    source
    fn SelfAttentionConfig::score_scale(self : SelfAttentionConfig) -> Float

    SelfAttentionConfig::width

    source
    fn SelfAttentionConfig::width(self : SelfAttentionConfig) -> Int

    SelfAttentionParameters

    source
    pub struct SelfAttentionParameters {
      width_ : Int
      heads_ : Int
      query_weight_ : Array[Float]
      query_bias_ : Array[Float]
      key_weight_ : Array[Float]
      key_bias_ : Array[Float]
      value_weight_ : Array[Float]
      value_bias_ : Array[Float]
      output_weight_ : Array[Float]
      output_bias_ : Array[Float]
    }

    SelfAttentionParameters::key_bias

    source

    SelfAttentionParameters::key_weight

    source
    fn SelfAttentionParameters::key_weight(self : SelfAttentionParameters) -> Array[Float]

    SelfAttentionParameters::matches

    source

    SelfAttentionParameters::new

    source
    fn SelfAttentionParameters::new(config : SelfAttentionConfig, query_weight : Array[Float], query_bias : Array[Float], key_weight : Array[Float], key_bias : Array[Float], value_weight : Array[Float], value_bias : Array[Float], output_weight : Array[Float], output_bias : Array[Float]) -> SelfAttentionParameters raise 
    TensorError

    SelfAttentionParameters::output_bias

    source
    fn SelfAttentionParameters::output_bias(self : SelfAttentionParameters) -> Array[Float]

    SelfAttentionParameters::output_weight

    source
    fn SelfAttentionParameters::output_weight(self : SelfAttentionParameters) -> Array[Float]

    SelfAttentionParameters::query_bias

    source
    fn SelfAttentionParameters::query_bias(self : SelfAttentionParameters) -> Array[Float]

    SelfAttentionParameters::query_weight

    source
    fn SelfAttentionParameters::query_weight(self : SelfAttentionParameters) -> Array[Float]

    SelfAttentionParameters::value_bias

    source
    fn SelfAttentionParameters::value_bias(self : SelfAttentionParameters) -> Array[Float]

    SelfAttentionParameters::value_weight

    source
    fn SelfAttentionParameters::value_weight(self : SelfAttentionParameters) -> Array[Float]

    TinyCnn

    source
    pub(all) struct TinyCnn[T] {
      convolution : Conv2dLayer[T]
      classifier : Linear[T]
    }

    TinyCnn::forward

    source
    fn[T : 
    TensorOps    ] TinyCnn::forward(self : TinyCnn[T], input : T) -> T raise

    TransformerBlock

    source
    pub(all) struct TransformerBlock[T] {
      input_projection : Linear[T]
      normalization_scale : T
      normalization_bias : T
      output_projection : Linear[T]
      normalization_axes : Array[Int]
      epsilon : Float
    }

    A fixed-shape Transformer-style feed-forward block.

    The first projection changes the feature width, layer normalization and GELU operate in that hidden space, and the second projection restores the input width before the residual addition.

    TransformerBlock::forward

    source
    fn[T : 
    TensorOps    ] TransformerBlock::forward(self : TransformerBlock[T], input : T) -> T raise

    TransformerEncoderBlock

    source
    pub(all) struct TransformerEncoderBlock[T] {
      attention_normalization : LayerNorm[T]
      attention : SelfAttention[T]
      feed_forward_normalization : LayerNorm[T]
      feed_forward : FeedForward[T]
    }

    A pre-normalization Transformer encoder block.

    Both sublayers share the same backend type, so one model definition can be materialized for CPU or WebNN execution. SelfAttention and FeedForward do not own residual connections; this block defines both residual boundaries.

    TransformerEncoderBlock::forward

    source

    TransformerEncoderConfig

    source
    pub struct TransformerEncoderConfig {
      attention_ : SelfAttentionConfig
      hidden_size_ : Int
      input_rank_ : Int
      epsilon_ : Float
    }

    TransformerEncoderConfig::attention

    source

    TransformerEncoderConfig::epsilon

    source

    TransformerEncoderConfig::heads

    source

    TransformerEncoderConfig::hidden_size

    source
    fn TransformerEncoderConfig::hidden_size(self : TransformerEncoderConfig) -> Int

    TransformerEncoderConfig::input_rank

    source

    TransformerEncoderConfig::new

    source
    fn TransformerEncoderConfig::new(width : Int, heads : Int, hidden_size : Int, input_rank : Int, epsilon : Float) -> TransformerEncoderConfig raise 
    TensorError

    TransformerEncoderConfig::normalization_axis

    source
    fn TransformerEncoderConfig::normalization_axis(self : TransformerEncoderConfig) -> Int

    TransformerEncoderConfig::width

    source

    TransformerEncoderParameters

    source
    pub struct TransformerEncoderParameters {
      width_ : Int
      heads_ : Int
      hidden_size_ : Int
      attention_normalization_scale_ : Array[Float]
      attention_normalization_bias_ : Array[Float]
      attention_ : SelfAttentionParameters
      feed_forward_normalization_scale_ : Array[Float]
      feed_forward_normalization_bias_ : Array[Float]
      feed_forward_ : FeedForwardParameters
    }

    TransformerEncoderParameters::attention

    source

    TransformerEncoderParameters::attention_normalization_bias

    source
    fn TransformerEncoderParameters::attention_normalization_bias(self : TransformerEncoderParameters) -> Array[Float]

    TransformerEncoderParameters::attention_normalization_scale

    source
    fn TransformerEncoderParameters::attention_normalization_scale(self : TransformerEncoderParameters) -> Array[Float]

    TransformerEncoderParameters::feed_forward

    source

    TransformerEncoderParameters::feed_forward_normalization_bias

    source
    fn TransformerEncoderParameters::feed_forward_normalization_bias(self : TransformerEncoderParameters) -> Array[Float]

    TransformerEncoderParameters::feed_forward_normalization_scale

    source
    fn TransformerEncoderParameters::feed_forward_normalization_scale(self : TransformerEncoderParameters) -> Array[Float]

    TransformerEncoderParameters::matches

    source

    TransformerEncoderParameters::new

    source
    fn TransformerEncoderParameters::new(config : TransformerEncoderConfig, attention_normalization_scale : Array[Float], attention_normalization_bias : Array[Float], attention : SelfAttentionParameters, feed_forward_normalization_scale : Array[Float], feed_forward_normalization_bias : Array[Float], feed_forward : FeedForwardParameters) -> TransformerEncoderParameters raise 
    TensorError

    TransformerEncoderStack

    source
    pub struct TransformerEncoderStack[T] {
      layers_ : Array[TransformerEncoderBlock[T]]
    }

    A non-empty sequence of pre-normalization Transformer encoder blocks.

    TransformerEncoderStack::forward

    source

    TransformerEncoderStack::layer_count

    source
    fn[T] TransformerEncoderStack::layer_count(self : TransformerEncoderStack[T]) -> Int

    TransformerEncoderStack::new

    source

    TransformerEncoderStackConfig

    source
    pub struct TransformerEncoderStackConfig {
      encoder_ : TransformerEncoderConfig
      layers_ : Int
    }

    TransformerEncoderStackConfig::encoder

    source

    TransformerEncoderStackConfig::layers

    source

    TransformerEncoderStackConfig::new

    source
    fn TransformerEncoderStackConfig::new(layers : Int, width : Int, heads : Int, hidden_size : Int, input_rank : Int, epsilon : Float) -> TransformerEncoderStackConfig raise 
    TensorError

    TransformerEncoderStackParameters

    source
    pub struct TransformerEncoderStackParameters {
      layers_ : Array[TransformerEncoderParameters]
    }

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io