Test the basic functionality with default parameters.

get_frames_at with all frame indices succeeds on first try.

Every batch must satisfy three invariants: 1. Contains >= 2 distinct labels. 2. Every label in the batch appears >= 2 times. 3. Non-last

get_frames_at(n) fails but get_frames_at(n-1) succeeds.

Test batch_size parameter.

For dims divisible by 8, the packed shape must equal (n, dim // 8).

quantize_embeddings must not crash for embedding dimensions not divisible by 8.

Each row is packed independently. An all-positive row must not bleed into an all-negative one.

Test cache_folder parameter.

When cache_folder is None, it should fall back to SENTENCE_TRANSFORMERS_HOME env var.

The cache key must incorporate the prompt arguments, so a different `query_prompt` produces its own cache file rather than silently reusing embedd

``mini_batch_size`` only bounds memory: the cached loss must reproduce MultipleNegativesRankingLoss's loss and gradient, whether or not it divides

The prompt (and task) must be carried into the backward hook's re-prediction: they change the tokenization, so if the hook's bundle dropped them,

The backward pass must re-predict exactly the logits of the forward pass, dropout included. ``RandContext`` can only capture the RNG state of dev

Scaling the returned loss (gradient accumulation, fp16 loss scaling) must scale the whole gradient.

Each forward pass must hand its own cached gradients to its own backward hook. The cache used to live on the loss module, where a second forward p

The loss must be computable under ``torch.no_grad``, as the trainer does for the eval loss.

Explicit hard negatives (a third input column) triple the pair count. The cached loss must still reproduce the non-cached loss and gradient.

``mini_batch_size`` only bounds memory: for the 2- and 3-column shapes the non-cached loss supports, the cached loss must reproduce GISTEmbedLoss'

A Router keeps its input modules one level down, so a guard that only inspects ``model[0]`` waves a StaticEmbedding straight through, and mini-bat

The backward pass must re-embed exactly what the forward pass embedded, dropout included, also with this loss's bespoke ``embed_minibatch``, which

The token budget must flow through this loss's bespoke ``embed_minibatch_iter`` (which also runs the guide model) without changing the loss or gra

Each forward pass must hand its own cached gradients to its own backward hook. The cache used to live on the loss module, so a second forward pas

Single-process gather guard for the GradCache loss: the gather block must run (all_gather no-ops without a process group) and produce a finite, di

GradCache's contract is gradient equivalence with the non-cached loss. Regression pin for the per-chunk backward normalization: it must run on the

Cross-column varlen through the GradCache path. Exercises the same surface as the non-cached MNRL test but with chunked embedding forward + cached

The GradCache cat path pads each mini-batch chunk to a common ``T`` before concatenating, so native-resolution VLMs that emit different ``T`` per

The constructor runs the shared validation, so a non-positive budget fails at build time rather than producing a degenerate mini-batch split later

Native-resolution VLM columns (Qwen2-VL family) flatten per-sample visual tokens into one ``pixel_values`` tensor with an ``image_grid_thw`` row p

The GradCache second pass re-embeds from the same feature dicts: the stamped task must govern both the no-grad forward and the with-grad re-run.

``mini_batch_num_tokens`` packs mini-batches by real token count rather than by sequence count, which must not change the loss or the gradients. P

Gradient caching must produce the loss and gradient of the non-cached loss, for any configuration and whether or not ``mini_batch_size`` divides (

The trainer back-propagates the sum of the returned dict, so the components must sum exactly to the gradient-carrying total even though only one e

An inference-free SPLADE model routes queries through a (frozen) SparseStaticEmbedding, whose embeddings then don't require grad. The backward hoo

A dict-valued base loss must keep its own component keys in the returned dict, exactly as SpladeLoss spreads them. The separate keys are the point

``mini_batch_size`` only bounds memory: the cached loss must reproduce SpladeLoss's total loss, per-component values, and gradients, whether or no

The backward pass must re-embed exactly what the forward pass embedded, dropout included, making this loss self-guarding instead of relying only o

The token budget must reproduce SpladeLoss's per-component losses and gradients.

Each forward pass must hand its own cached gradients to its own backward hook.

The eval loss must be computable under ``torch.no_grad`` and match the training-path total.

The deprecated symmetric shim only wires ``directions`` and ``partition_mode`` into the composed loss, and that wiring has no test of its own. The

Second call for same VideoDecoder returns cached path without incrementing counter.

A StaticEmbedding model (non-Transformer first module) should not support flattened inputs.

_can_flatten_inputs should delegate to the Transformer module's can_flatten_inputs attribute.

A batch with nothing to pad has no last-token problem, whatever padding_side says.

padding_side is set to "left" on load, so reaching this means it was mutated afterwards.

A multimodal processor pads via its tokenizer and has no padding_side of its own, so the tokenizer attribute is the only one that can be wrong

processing_kwargs overrides the attribute at call time, so the attribute alone can't be trusted: it still reads "left" here while the processo

TINY_LLAMA has a chat template, so text normally routes through apply_chat_template, which only forwards the "text" bucket. Without a "message

The module sets padding_side to "left" on load, so a ragged batch ends in real tokens.

Chat-template backbones own their query augmentation in the template (the colpali-engine suffix pattern): preprocess forwards ``task`` into ``appl

Development installs and torch nightlies must not trip the check.

CUDA builds report versions like 2.13.0+cu126.

Specifiers are validated before the installed version, so a typo can't raise for anyone.

Model authors copying the "pytorch" spelling from the `__version__` block should still work.