All Classes and Interfaces

Class
Description
AdaDelta (Zeiler), PyTorch's semantics: decay rho, eps, learning rate (default 1), L2 weight decay.
AdaGrad (Duchi et al.), PyTorch's semantics: learning-rate decay, L2 weight decay, initial accumulator.
Adam (Kingma and Ba) with L2 weight decay, or AdamW (decoupled decay) via Adam.adamW(List, float, float); with amsgrad, AMSGrad's running maximum of the second moment (Reddi et al.).
AdaMax (Kingma and Ba): Adam with an infinity norm, PyTorch's semantics, L2 weight decay.
Adaptive average pooling to fixed output sizes (1 to 3 spatial axes), PyTorch's nn.AdaptiveAvgPool1d/2d/3d.
Adaptive max pooling to fixed output sizes (1 to 3 spatial axes), PyTorch's nn.AdaptiveMaxPool1d/2d/3d.
Residual connection: relu(main(x) + shortcut(x)) or main(x) + shortcut(x).
Mixed precision, per thread: inside Autocast.enable(DType), F.linear(Tensor, Tensor, Tensor), Tensor.matmul(Tensor) and the products of F.scaledDotProductAttention(Tensor, Tensor, Tensor, Tensor, boolean, float) cast their operands to FP16 or BF16 and run the half-precision GEMMs, accumulating in FP32.
Average pooling over 1-D windows, PyTorch's nn.AvgPool1d.
Average pooling; padding counts in the divisor, as PyTorch's default.
Average pooling over 3-D windows, PyTorch's nn.AvgPool3d.
Where operators run.
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.
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).
A synthetic classification set: classes Gaussian clusters in dims dimensions.
Runs models on inputs padded to Buckets sizes, so requests of changing batch and sequence length reuse a few compiled plans, and returns results for the real rows and positions only.
A fixed set of sizes that a changing dimension (batch, sequence length) is rounded up to, so requests of many shapes run a few compiled plans instead of compiling one per shape, as TensorRT's optimization profiles or vLLM's CUDA-graph batch sizes do.
CELU with alpha (PyTorch's default 1).
A recurrent language model: token embedding, a stack of LSTM or GRU layers, a linear head over the vocabulary.
CIFAR-10 from the binary distribution (cifar-10-batches-bin: data_batch_1..5.bin and test_batch.bin, each record a label byte and 3072 pixel bytes in CHW order).
Collective communication among the ranks of a group, each rank one thread and usually one device (after torch.distributed).
How a reduction combines the ranks' tensors, element-wise.
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.
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.
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.
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.
Training examples for the embedding models, drawn on the host from sentences of word ids: skip-gram pairs, CBOW windows, negative samples from the unigram distribution raised to 3/4, and GloVe's distance-weighted co-occurrence counts.
x^3.
An operator defined outside jitNN: a kernel written in plain Java with TornadoVM's KernelContext, an optional host reference and an optional gradient.
Gradients with respect to each input (null where none is needed), given the gradient of the first output.
The gradients of an element-wise binary operator y = f(a, b): [dL/da, dL/db] from a, b, y and dL/dy.
Defines a custom operator step by step; CustomOp.Builder.build() registers its name.
Adds the operator's device tasks for node to the plan being built.
The shape of an output, from the inputs and the integer attributes of the call.
Computes node on the host: inputs are readable, outputs are allocated.
The gradient of an element-wise unary operator y = f(x): dL/dx from x, y and dL/dy.
Batches of a Dataset for training, as PyTorch's DataLoader: shuffled per epoch from a seed, optional per-sample transforms (augmentation), the last short batch kept or dropped, and batches assembled ahead by worker threads while the device computes.
One batch: samples [size, ...sampleShape] and labels [size], host tensors.
Options of a DataLoader: shuffling, worker threads, prefetching.
Data-parallel training with one model replica per rank (see ProcessGroup): broadcast rank 0's parameters once, then after each backward pass average the gradients over the ranks before the optimiser step, so every replica takes the same step, as PyTorch's DistributedDataParallel does.
An in-memory labelled dataset of fixed-shape samples (CHW images or flat vectors).
DCGAN (Radford et al., 2016) for 28x28 single-channel images: a generator from a latent vector through a 7x7 feature map and two stride-2 transposed convolutions to a tanh image, and a discriminator of two stride-2 convolutions with LeakyReLU(0.2) and a linear logit.
Images [B, 1, 28, 28] to logits [B, 1].
z [B, latent] to images [B, 1, 28, 28] in [-1, 1].
Paragraph vectors (Le and Mikolov, 2014) with negative sampling.
How a document's words are predicted.
Inverted dropout in training mode, identity in evaluation mode.
Element type of a tensor: FP32 data, INT32 labels and indices, and the half-precision storage types for mixed precision, IEEE FP16 and bfloat16 (the top 16 bits of an FP32), and Q8_0, GGUF's 8-bit blocks (per 32 consecutive values an FP16 scale and 32 signed bytes, 34 bytes), and the OCP 8-bit floats FP8 E4M3 and E5M2, one byte per value, stored without their scale (see Fp8).
ELU with slope alpha for negative inputs (PyTorch's default 1).
A lookup table of count vectors of size dim, applied to INT32 indices.
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.
What an operator sees while its device tasks are added to a task graph: the arrays bound to its tensors, constant metadata arrays, and helpers for launch grids.
Adds one task to the graph under the given task id.
Functional operators that are not methods of Tensor.
How F.pad(Tensor, int[], int[], F.PadMode, float) fills: a constant, the reflection without the edge, or the edge replicated.
How a loss reduces its per-element values.
Fourier transforms after torch.fft, and the short-time transforms torch.stft and torch.istft.
Scaling, torch's norm: BACKWARD scales the inverse by 1/n, ORTHO both by 1/sqrt(n), FORWARD the forward by 1/n.
[N, d1, d2, ...] to [N, d1 * d2 * ...], a view.
The tensor element types a GGUF file can hold (ggml's ggml_type), with their ids, block sizes and the jitNN DType each one loads as.
A GGUF file (llama.cpp's model format, versions 2 and 3): its metadata and its tensors, which load as persistent jitNN tensors.
One tensor listed in a GGUF file.
[N, C, H, W] to [N, C], the mean over each feature map (adaptive average pooling to 1x1, flattened).
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).
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).
Whether new operators record what autograd needs.
A try-with-resources scope that restores the previous gradient mode.
Gradient-boosted trees with second-order (Newton) leaves on binned features, after scikit-learn's HistGradientBoosting and XGBoost: squared error for regression, the logistic loss for two classes and the softmax loss (one tree per class and round) for more.
Dynamic loss scaling for FP16 training, as PyTorch's torch.amp.GradScaler: the loss is multiplied by a scale before backward; GradScaler.unscale(Optimizer) makes the optimiser divide the gradients by it (inside the update, together with any clipping) and look for overflows on the device; GradScaler.step(Optimizer) runs the optimiser, which skips the update on the device when an overflow was found; GradScaler.update() (after the step has run, e.g. after loss.item()) halves the scale on an overflow, or doubles it after growthInterval clean steps.
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].
GroupNorm over [N, C, ...] with a per-channel affine (weight 1, bias 0 at the start), PyTorch's nn.GroupNorm.
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)).
Output sequence of the last layer [T, B, directions H] and the final hidden states, [layers directions, B, H] each.
HardSigmoid: clamp(x / 6 + 1/2, 0, 1).
HardSwish: x hardSigmoid(x).
HardTanh: x clamped to [min, max].
A Hugging Face model directory: config.json and the weights in model.safetensors or in shards listed by model.safetensors.index.json.
Collectives staged through host memory: each rank copies its tensor to the host, the reduction runs on the host in rank order (so every rank gets bit-identical results, run after run), and each rank copies the result back.
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).
jitNN's options, in one immutable object.
Builds a configuration option by option.
One option: its key, type, default and description.
The groups options are listed in.
A DJL engine that runs DJL code on jitNN: NDArray operators become lazy jitNN operators, compiled into one TornadoVM plan per step and replayed; DJL's blocks, losses, optimisers and trainers work on top, and Model.load reads ONNX files through jitnn-onnx.
Registers JitnnEngine with DJL (through META-INF/services).
A failure of the device or the runtime: a plan that TornadoVM could not compile or run, a vendor library call that failed, a native library of the CPU backend that could not be called.
A DJL model on jitNN.
A DJL NDArray backed by a lazy jitNN tensor.
Creates JitnnNDArrays.
jitNN's runtime: where operators run, sync points, determinism, profiling and statistics.
An ONNX model loaded by jitnn-onnx, as a DJL block.
A small JSON reader for the files jitNN loads (safetensors headers, Hugging Face configs and tokenizers): objects become LinkedHashMaps in file order, arrays Lists, integers Long, other numbers Double.
k-means clustering with Lloyd's algorithm, after scikit-learn's KMeans: k-means++ seeding (or given initial centres), nInit restarts keeping the lowest inertia, and stopping when the assignments no longer change or the centres move less than tol times the mean feature variance.
k-nearest neighbours by brute force on the device (Euclidean distance, uniform weights), after scikit-learn's KNeighborsClassifier and KNeighborsRegressor.
LAMB (You et al., 2020): Adam's bias-corrected update plus decoupled weight decay, scaled per parameter by the trust ratio |p| / |update|.
LARS (You et al., 2017) with momentum: a per-parameter learning rate eta |p| / (|g| + weightDecay |p|), applied to the decayed gradient and accumulated in a momentum buffer.
LayerNorm over the last axis, with weight 1 and bias 0 initially, like PyTorch's nn.LayerNorm.
LeakyReLU with a fixed negative slope (PyTorch's default 0.01).
Linear algebra on matrices and batches of matrices [..., rows, cols], after torch.linalg: LU, triangular and general solves, inverse, determinants, Cholesky, QR, symmetric eigendecomposition and SVD.
y = x W^T + b with W of shape [out, in].
Least squares with an optional L2 penalty alpha (ridge regression), solved in closed form from the normal equations (X^T X + alpha I) w = X^T y on centred data, after scikit-learn's LinearRegression (alpha 0) and Ridge.
Linear support vector classification with the squared hinge loss, one-vs-rest, after scikit-learn's LinearSVC (liblinear, intercept_scaling 1): for each class it minimises ||[w, b]||^2 / 2 + C sum_i max(0, 1 - y_i (w . x_i + b))^2, the intercept penalised like a weight, with L-BFGS (the objective is smooth).
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.
Local response normalisation across channels, PyTorch's nn.LocalResponseNorm.
L2-regularised logistic regression fitted with L-BFGS, after scikit-learn's LogisticRegression (lbfgs): it minimises C sum_i loss_i + ||W||^2 / 2 with the intercept unpenalised; a sigmoid for two classes, the multinomial (softmax) loss for more.
Sets an optimiser's learning rate per epoch; call LRScheduler.step() once at the end of each epoch, as with PyTorch's schedulers.
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)).
Output sequence of the last layer [T, B, directions H] and the final hidden states and cell states, [layers directions, B, H] each.
Max pooling over 1-D windows, PyTorch's nn.MaxPool1d.
Max pooling over square windows of NCHW input, PyTorch's nn.MaxPool2d.
Max pooling over 3-D windows, PyTorch's nn.MaxPool3d.
Mish: x tanh(softplus(x)).
Reads the MNIST IDX files (train-images-idx3-ubyte[.gz] and friends) from a directory.
MobileNetV2 (Sandler et al., 2018), torchvision's layout: inverted residual blocks (1x1 expand, 3x3 depthwise, 1x1 linear projection) with ReLU6.
A differentiable building block with parameters and child modules.
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.
NAdam (Dozat), PyTorch's semantics: momentum decay psi (default 0.004), L2 weight decay.
Naive Bayes classifiers after scikit-learn's GaussianNB (per-class means and variances, the variances smoothed by varSmoothing times the largest feature variance) and MultinomialNB (feature counts with additive smoothing alpha).
Which likelihood the features follow.
Collectives on the GPUs, through NCCL (TornadoVM's tornado-nccl): one rank per CUDA device, in one process.
One operator application.
Writes a jitNN forward pass as an ONNX model (opset 20), for ONNX Runtime and the other ONNX tools.
An ONNX model as read from its file: the main graph's nodes, initializers, inputs and outputs, and the operator-set versions.
An attribute of a node; which fields are set depends on its type.
A graph: its nodes in topological order, the initializers (weights and constants) by name, and its inputs and outputs.
A node of the graph: an operator application, with the names of its input and output values.
A tensor stored in the model: dims, element type and its data as little-endian bytes.
A graph input or output: name, element type and dims (-1 for a symbolic dimension), with the symbolic dimensions' names (dim_param, null where a dimension has none or dims is null).
Runs an ONNX model with jitNN: each node becomes jitNN operations, so a call records one trace that jitNN compiles into a TornadoVM plan on the first run and replays afterwards (same input shapes).
Updates parameters in place from their gradients.
Padding of the spatial axes: constant, reflect or replicate (PyTorch's nn.ConstantPadNd, ReflectionPadNd, ReplicationPadNd).
Principal component analysis from the eigendecomposition of the covariance matrix, after scikit-learn's PCA: components as rows, ordered by explained variance, each signed so that its largest-magnitude entry is positive (scikit-learn's svd_flip convention).
PReLU with a learnable slope, one shared or one per channel, initialised to init (PyTorch: 0.25).
Runs one rank per device in this process: rank firstRank + r is a thread whose plans run on devices[r] (see Engine.onDevice(String, Supplier)), and all ranks share one Collective.
A reader for the protocol buffers wire format, enough to decode ONNX's messages without a protobuf library: varints, fixed 32/64-bit values and length-delimited fields (strings, bytes, nested messages and packed repeated numbers).
Receives double values from Proto.doubles(Proto.DoubleSink).
Receives float values from Proto.floats(Proto.FloatSink).
Receives int64 values from Proto.longs(Proto.LongSink).
Random forests (Breiman, 2001) and single decision trees on binned features: trees grown on bootstrap samples (weights drawn on the host) with a random subset of the features at each split, predictions averaged.
What the forest predicts.
ReLU: max(x, 0).
ReLU6: min(max(x, 0), 6).
ResNet (He et al., 2016).
RMSNorm over the last axis, with weight 1 initially, like PyTorch's nn.RMSNorm.
RMSProp (Hinton), PyTorch's semantics: smoothing alpha, optional momentum and centring, L2 weight decay.
A rescaling of the rotary position embedding's frequencies, as Hugging Face's rope_scaling.
Positions divided by factor.
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.
Reads and writes the safetensors format (Hugging Face): an 8-byte little-endian header length, a JSON header that maps each tensor name to its dtype, shape and byte range, optional __metadata__ string pairs, then the raw little-endian data. jitNN's checkpoints use it, so they open in Python with safetensors.torch.load_file.
One tensor of a file: its type (null when jitNN has no such type, e.g.
A file's header: the tensors, in file order, and the metadata.
The data to write for one tensor: its type, shape, and a segment of exactly its bytes.
SELU with PyTorch's constants.
Applies its modules in order.
Stochastic gradient descent with optional (Nesterov) momentum and L2 weight decay, as in PyTorch.
An immutable, row-major tensor shape.
The logistic sigmoid 1 / (1 + exp(-x)).
Softplus: log(1 + exp(x)).
Softsign: x / (1 + |x|).
The structure of a sparse matrix (which entries are stored), built once on the host from coordinate lists; the values are a separate tensor, in the order the coordinates were given, so they can be learned.
A structure with fixed values.
Named tensors and string values: the state of a model, an optimiser or a whole training run, as PyTorch's state_dict.
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.
The hyperbolic tangent.
An n-dimensional array.
A byte-level text corpus for language-model gates: every byte is a token (vocabulary 256).
A TensorFlow model on jitNN: a SavedModel directory (TensorFlow 2 / Keras export, with its variables checkpoint) or a frozen GraphDef file.
Keras's ThresholdedReLU: x where x > theta, else 0.
A Hugging Face tokenizer read from its tokenizer.json, for the two families jitNN's models use: WordPiece with the BERT normaliser and pre-tokeniser (BERT and its relatives), and byte-level BPE (GPT-2, RoBERTa).
Encodings padded to the longest one: [batch, length] ids and type ids, and an attention mask of 1 for tokens and 0 for padding.
The ids, type ids and tokens of one text (or pair), special tokens included.
Per-sample transforms for DataLoader, applied in place to one CHW sample on the host: the usual image augmentations and normalisation.
Transforms one sample of shape at x[at ..] in place.
Exact t-SNE (van der Maaten and Hinton, 2008) on the device, after scikit-learn's TSNE with method="exact": Gaussian affinities calibrated per point to the perplexity by bisection on the precision, symmetrised; a Student-t kernel in the embedding; gradient descent with momentum (0.5, then 0.8), early exaggeration (12 for 250 iterations), per-parameter gains (+0.2 / x0.8, at least 0.01) and the learning rate max(n / 12 / 4, 50).
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.
Nearest or bilinear upsampling of NCHW by a scale factor, PyTorch's nn.Upsample.
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.
Reconstruction probabilities [B, in] and the latent mean and log-variance [B, latent].
Word ids by descending frequency, the words seen at least minCount times.
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).
Which word predicts which.