Uses of Class
ai.beestream.jitnn.nn.Module

Packages that use Module
Package
Description
Neural-network modules after PyTorch's torch.nn: Module and Sequential, linear and convolution layers, pooling, normalisation, attention, embeddings, recurrent layers (LSTM, GRU), graph convolution, activations, and data-parallel training (DataParallel).
Complete models: ResNet, MobileNetV2, GPT-2, a Llama-style decoder, BERT, a VAE, DCGAN, U-Net and character RNNs, and the embedding models word2vec, doc2vec and GloVe.
  • Uses of Module in ai.beestream.jitnn.nn

    Subclasses of Module in ai.beestream.jitnn.nn
    Modifier and Type
    Class
    Description
    final class 
    Adaptive average pooling to fixed output sizes (1 to 3 spatial axes), PyTorch's nn.AdaptiveAvgPool1d/2d/3d.
    final class 
    Adaptive max pooling to fixed output sizes (1 to 3 spatial axes), PyTorch's nn.AdaptiveMaxPool1d/2d/3d.
    final class 
    Residual connection: relu(main(x) + shortcut(x)) or main(x) + shortcut(x).
    final class 
    Average pooling over 1-D windows, PyTorch's nn.AvgPool1d.
    final class 
    Average pooling; padding counts in the divisor, as PyTorch's default.
    final class 
    Average pooling over 3-D windows, PyTorch's nn.AvgPool3d.
    final class 
    Batch normalisation over the channels of NCHW (or NC) input, PyTorch defaults: weight 1, bias 0, running mean 0 and variance 1, momentum 0.1, eps 1e-5.
    final class 
    CELU with alpha (PyTorch's default 1).
    final class 
    1-D convolution over [N, C, ...] with a cubic kernel, optionally grouped, PyTorch's initialisation: weight and bias uniform in [-1/sqrt(fan_in), 1/sqrt(fan_in)), fan_in = in * kernel^1.
    final class 
    2-D convolution over NCHW with a square kernel, PyTorch's nn.Conv2d semantics and initialisation: weight and bias uniform in [-1/sqrt(fan_in), 1/sqrt(fan_in)), fan_in = in/groups * k * k.
    final class 
    3-D convolution over [N, C, ...] with a cubic kernel, optionally grouped, PyTorch's initialisation: weight and bias uniform in [-1/sqrt(fan_in), 1/sqrt(fan_in)), fan_in = in * kernel^3.
    final class 
    Transposed 2-D convolution over NCHW with a square kernel, PyTorch's nn.ConvTranspose2d semantics and initialisation: weight [in, out/groups, k, k] and bias uniform in [-1/sqrt(fan_in), 1/sqrt(fan_in)), fan_in = out/groups * k * k.
    final class 
    x^3.
    final class 
    Inverted dropout in training mode, identity in evaluation mode.
    final class 
    ELU with slope alpha for negative inputs (PyTorch's default 1).
    final class 
    A lookup table of count vectors of size dim, applied to INT32 indices.
    final class 
    EmbeddingBag: bags of INT32 indices (one flat list plus bag offsets) to the sum, mean or max of their embedding rows, PyTorch's nn.EmbeddingBag with standard normal initial weights.
    final class 
    [N, d1, d2, ...] to [N, d1 * d2 * ...], a view.
    final class 
    [N, C, H, W] to [N, C], the mean over each feature map (adaptive average pooling to 1x1, flattened).
    final class 
    Graph convolution (Kipf and Welling, 2017), PyTorch Geometric's GCNConv:  (x W^T) + b, with  the normalised adjacency SparseMatrix.gcn(int, int[], int[]) of the graph, given with each call since one layer serves many graphs. x [nodes, in] gives [nodes, out].
    final class 
    GroupNorm over [N, C, ...] with a per-channel affine (weight 1, bias 0 at the start), PyTorch's nn.GroupNorm.
    final class 
    A stack of GRU layers over [T, B, I] sequences (time first), optionally bidirectional, PyTorch's nn.GRU equations, gate order, parameter order and initialisation: every weight and bias uniform in [-1/sqrt(H), 1/sqrt(H)).
    final class 
    HardSigmoid: clamp(x / 6 + 1/2, 0, 1).
    final class 
    HardSwish: x hardSigmoid(x).
    final class 
    HardTanh: x clamped to [min, max].
    final class 
    InstanceNorm over [N, C, ...]: each sample and channel normalised over its positions, PyTorch's nn.InstanceNorm1d/2d/3d without running statistics; affine optional (PyTorch's default: none).
    final class 
    LayerNorm over the last axis, with weight 1 and bias 0 initially, like PyTorch's nn.LayerNorm.
    final class 
    LeakyReLU with a fixed negative slope (PyTorch's default 0.01).
    final class 
    y = x W^T + b with W of shape [out, in].
    final class 
    Local response normalisation across channels, PyTorch's nn.LocalResponseNorm.
    final class 
    A stack of LSTM layers over [T, B, I] sequences (time first), optionally bidirectional, PyTorch's nn.LSTM equations, gate order, parameter order and initialisation: every weight and bias uniform in [-1/sqrt(H), 1/sqrt(H)).
    final class 
    Max pooling over 1-D windows, PyTorch's nn.MaxPool1d.
    final class 
    Max pooling over square windows of NCHW input, PyTorch's nn.MaxPool2d.
    final class 
    Max pooling over 3-D windows, PyTorch's nn.MaxPool3d.
    final class 
    Mish: x tanh(softplus(x)).
    final class 
    Multi-head self-attention on [B, T, D] inputs, like PyTorch's nn.MultiheadAttention with batch_first: one fused q/k/v projection [3D, D], heads heads of D / heads features, and an output projection.
    final class 
    Padding of the spatial axes: constant, reflect or replicate (PyTorch's nn.ConstantPadNd, ReflectionPadNd, ReplicationPadNd).
    final class 
    PReLU with a learnable slope, one shared or one per channel, initialised to init (PyTorch: 0.25).
    final class 
    ReLU: max(x, 0).
    final class 
    ReLU6: min(max(x, 0), 6).
    final class 
    RMSNorm over the last axis, with weight 1 initially, like PyTorch's nn.RMSNorm.
    final class 
    RReLU: random slopes in [lower, upper) while training (a fresh seed per call, so a replayed step draws new slopes without recompiling), the mean slope in evaluation.
    final class 
    SELU with PyTorch's constants.
    final class 
    Applies its modules in order.
    final class 
    The logistic sigmoid 1 / (1 + exp(-x)).
    final class 
    Softplus: log(1 + exp(x)).
    final class 
    Softsign: x / (1 + |x|).
    final class 
    Batch normalisation whose training statistics are those of the batch over all data-parallel ranks, as PyTorch's SyncBatchNorm: each rank sums its x and x^2 per channel, one all-reduce gives the global mean and variance, and the backward pass all-reduces their gradients the same way.
    final class 
    The hyperbolic tangent.
    final class 
    Keras's ThresholdedReLU: x where x > theta, else 0.
    final class 
    Nearest or bilinear upsampling of NCHW by a scale factor, PyTorch's nn.Upsample.
    Methods in ai.beestream.jitnn.nn with type parameters of type Module
    Modifier and Type
    Method
    Description
    protected <M extends Module>
    M
    Module.child(M module)
    Adds a child module; returns it.
    Methods in ai.beestream.jitnn.nn that return Module
    Modifier and Type
    Method
    Description
    DataParallel.module()
    The wrapped replica.
    Module.train(boolean on)
    Switches this module and its children to training mode (on) or evaluation mode; returns this module.
    Constructors in ai.beestream.jitnn.nn with parameters of type Module
    Modifier
    Constructor
    Description
     
    Add(Module main, Module shortcut, boolean relu)
    shortcut null means identity.
     
    DataParallel(Module model, int rank, Collective collective)
    Wraps rank rank's replica model; ranks synchronise through collective.
     
    Sequential(Module... layers)
    The modules applied in order, each to the previous one's output.
  • Uses of Module in ai.beestream.jitnn.nn.models

    Modifier and Type
    Class
    Description
    final class 
    A BERT-style encoder for masked language modelling: token and learned position embeddings with LayerNorm, post-LayerNorm blocks of bidirectional attention (with an additive padding mask) and a GELU MLP of 4 x dim, and an MLM head (dense, GELU, LayerNorm, then the token embedding as the decoder with its own bias).
    final class 
    A recurrent language model: token embedding, a stack of LSTM or GRU layers, a linear head over the vocabulary.
    static final class 
    Images [B, 1, 28, 28] to logits [B, 1].
    static final class 
    z [B, latent] to images [B, 1, 28, 28] in [-1, 1].
    final class 
    Paragraph vectors (Le and Mikolov, 2014) with negative sampling.
    final class 
    GloVe (Pennington et al., 2014): word and context vectors with biases fitted to the logarithm of the co-occurrence counts, weighted by f(x) = min(1, (x / xMax)^alpha).
    final class 
    A GPT-2 style decoder: token and learned position embeddings, pre-LayerNorm blocks of causal multi-head attention and a GELU (tanh form) MLP of 4 x dim, a final LayerNorm, and logits from the token embedding (tied weights).
    final class 
    A Llama-style decoder: token embedding, pre-RMSNorm blocks of causal attention with rotary position embedding (rotate-half form) and a SwiGLU feed-forward, a final RMSNorm and an untied output projection; no biases.
    final class 
    A small U-Net (Ronneberger et al., 2015) for 28x28 inputs with two down-sampling levels: double 3x3 convolutions with ReLU, max pooling, a bottleneck, then one level up through a stride-2 transposed convolution and one through bilinear upsampling and a 1x1 convolution, each concatenated with the encoder's features of that size; a 1x1 convolution gives one logit per pixel.
    final class 
    A fully connected variational autoencoder (Kingma and Welling, 2014), the layout of PyTorch's MNIST example: 784-400 encoder to a Gaussian latent (mean, log-variance), 400-784 decoder with a sigmoid output.
    final class 
    word2vec (Mikolov et al., 2013) with negative sampling: an input embedding (the word vectors) and an output embedding, initialised like the original C code (input uniform in +-0.5 / dim, output zero).