🥮 mooncakes.io
README

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