All Classes and Interfaces
Class
Description
Adapts DeepJ activations to the existing Layer contract.
Composable encoder/decoder, sharing the same parameter and autograd system as every DeepJ layer.
Internal lifetime tracking for non-escaping buffers produced by library backward rules.
A first-order vector-Jacobian product, in the same order as the operation's inputs.
Channel-axis (axis 1) normalization, using backend reductions and persistent FLOAT32 running statistics.
Measures synthetic full training steps without reading datasets or saving checkpoints.
Synthetic full training updates; reads no dataset or checkpoint and saves nothing.
Optional backend capability for memory-efficient, fused causal attention.
Output, row statistics and unrounded FP32 output needed by tiled backward.
Generation only: rolling mode preserves cached history rather than rebuilding each shifted window.
Temporal cross-correlation for [batch, channels, length], sharing the 2D implementation.
Cross-correlation of [batch, channels, height, width] inputs, using gather and matrix multiplication.
Logical-layout Adam arithmetic matches the original contiguous FLOAT32 update order.
Assigns logical values with explicit dtype conversion, including overlapping source/destination views.
Stable final-axis loss and FLOAT32 gradient, including strided/compact logits and response masks.
CPU logical-layout kernels with real compact storage and FLOAT32 arithmetic.
Logical ND index selection and deterministic repeated-index accumulation.
General strided/broadcast CPU matmul; the existing FLOAT32 matrix fast path remains separate.
Last-axis CPU normalization, with FLOAT32 statistics and no intermediate compact rounding.
Typed position operations accumulate in FLOAT32 and round only the final stored activation.
Axis reductions accumulate in FLOAT32 and round compact output only once per result value.
Stable logical-axis softmax without an intermediate compact-dtype exponential tensor.
Two-pass FLOAT32 statistics without a full-sized FLOAT32 shadow of compact input.
Equal-shaped SwiGLU operands decode to FLOAT32 and only round the completed output.
Checked CPU row kernels; the Tensor facade owns autograd mutation fences as for other backends.
Class scores occupy the final axis; every leading position has one integer target.
Unfused backend composition preserves the original matrix loss/gradient evaluation order.
Terminal entry point; the Java library remains usable without the CLI dependencies.
A looped causal decoder reusing grouped-query attention and SwiGLU blocks across passes.
Unique layer counts and the number of fully differentiated recurrent passes.
A decoder with grouped-query attention, optional QK normalization, and tied embeddings.
Inverted dropout.
Dense floating-point storage formats.
Bidirectional multi-head attention with optional padding masks and backend-resident softmax.
Evaluates Nova on the same held-out FineWeb-Edu range used for Frisky.
Evaluates the looped decoder on the unchanged held-out FineWeb-Edu split.
Fine-tunes Nova on Frisky's unchanged response-only dataset.
Runs the fine_tune stage using the existing Frisky dataset.
Flattens an inclusive axis range; defaults to preserving the first (batch) axis.
One generation request.
Averages every spatial axis of [batch, channels, ...], returning [batch, channels].
Validates physical allocations without flattening logical tensor dimensions.
Runtime-only state; never serialized with a tensor or checkpoint.
Thread-local, nestable scope for computations that must not build a backward graph.
Opt-in opcode counter for the executed GPU command stream (-Ddeepj.graph.histogram=true).
Batch-first GRU layer; compose layers with Sequential for stacked recurrence.
Reset-after GRU, with reset/update/candidate gate order and separate projection biases.
Inference-only storage operations for head-major key/value caches.
Batch and head axes are distinct; packed matrices are temporary native-kernel views only.
Cache slots follow logical attention visits, so each repeated Loop pass has its own state.
Repeats shared grouped-query attention and SwiGLU blocks; each pass saves its own activations.
Batch-first LSTM layer; compose layers with Sequential for stacked recurrence.
LSTM with input/forget/candidate/output gate order and explicit cell memory.
Common validation for the existing rank-two CPU and native attention kernels.
Continues Nova on Frisky's unchanged broad instruction mixture.
Runs the midtrain stage using the existing Frisky dataset.
Embedded settings and storage counts, read without allocating model weights.
Validated model construction metadata,without allocating or converting tensor values.
Additive layer base with recursive training mode and identity-deduplicated parameters.
Mean squared error over equal, nonempty shapes, with FLOAT32 loss and gradients.
First-axis minibatching for images, sequences and matrices, using DeepJ's existing Trainer.
Versioned parameter/buffer archives for a separately constructed network.
Final-axis normalization accepts vector gains and the historical 1-by-width parameter layout.
The output uses promoted storage; normalized values and denominators retain FLOAT32 accumulation.
Adam updates accumulate in independent FLOAT32 parameter/master and moment buffers.
Explicit compatibility for packed matrix APIs,delegating their work to the same ND operators.
Logical dimensions for the compatibility API; never inferred from a GPU allocation's physical rows.
Explicit parameter storage policy: a requested dtype applies to multi-row parameters;
one-row parameters remain FLOAT32.
Max/average pooling of [batch, channels, length] inputs.
Floor-mode max/average pooling of channel-first images.
Independent leading positions share one projection; public activation axes remain intact.
Batch-first recurrent sequence execution, with optional lengths and caller-owned initial/final state.
Shared input/state validation and DeepJ linear projections for recurrent cells.
Batch-first sequence output and the final state of a recurrent layer.
Explicit caller-owned state.
Reshapes the full tensor, with at most one inferred (-1) dimension.
Batch-first RNN layer; compose layers with Sequential for stacked recurrence.
Elman recurrent cell with tanh activation.
Model activations use[batch,time,width]; historical single-sequence matrices remain explicit.
Ordered composition of existing or new DeepJ layers.
Validated logical checkpoint metadata; reading it never allocates tensor values.
Raw-bit, logical-order tensor payloads; no FLOAT32 shadow is needed for compact storage.
Backend copies plus a slicing autograd rule; never reads tensor values on the host.
Shape transformations retain one Tensor system and participate in first-order autograd.
Bounds internal view lifetimes, without releasing saved or explicitly retained storage.
Shared physical storage plumbing; logical Tensor operations remain on the concrete facade.
Predicts tokens using the same parameter that supplies the input embeddings.
Trains Nova from scratch using Frisky's FineWeb-Edu corpus and tokenizer.
Runs the pretrain stage using the existing Frisky dataset.
Stacked encoder for [batch, time, width] embeddings, with padding masks and masked mean pooling.
Pre-normalized encoder dimensions.
Pre-normalized, bidirectional encoder block reusing DeepJ linear layers and LayerNorm.
Floor-mode spatial window with symmetric zero padding and optional dilation.