Oct 29, 2026

Train adapters on top of FP8 weightsPython · 78 + / 43 −

Introduces 7 new declarations in src/transformers/integrations/finegrained_fp8.py.

Adds new core implementation rather than adjusting what was there. Tests changed with it, with code of their own.

src/transformers/integrations/finegrained_fp8.py ↗ · 3 files

@@ -282,6 +282,63 @@ def fp8_linear(     return finegrained_fp8_linear(input, weight, weight_scale_inv, block_size, bias, activation_scale)  +def _dequantize_fp8_weight(+    weight: torch.Tensor, weight_scale_inv: torch.Tensor, block_size: list[int] | None, dtype: torch.dtype+) -> torch.Tensor:+    """Dequantize `(..., N, K)` FP8 weights with their per-block (or per-tensor) scales, for the backward pass."""+    if weight.dtype == torch.int8:+        raise NotImplementedError("Backward through FP4 weights is not supported.")+    scale = weight_scale_inv.to(dtype)+    if block_size is not None:+        rows, cols = weight.shape[-2:]+        scale = scale.repeat_interleave(block_size[0], dim=-2)[..., :rows, :]+        scale = scale.repeat_interleave(block_size[1], dim=-1)[..., :cols]+    return weight.to(dtype).mul_(scale)+++class FP8LinearFunction(torch.autograd.Function):+    """+    `fp8_linear` with a backward for the input, so adapters (e.g. LoRA) can train on top of FP8 layers. The FP8 weights+    are frozen: the input gradient goes through the dequantized weight, and the weight, scales and bias get none.+    """++    @staticmethod+    def forward(ctx, input, weight, weight_scale_inv, block_size, bias, activation_scale, allow_deepgemm):+        ctx.save_for_backward(weight, weight_scale_inv)+        ctx.block_size = block_size+        return fp8_linear(input, weight, weight_scale_inv, block_size, bias, activation_scale, allow_deepgemm)++    @staticmethod+    def backward(ctx, grad_output):+        weight, weight_scale_inv = ctx.saved_tensors+        weight = _dequantize_fp8_weight(weight, weight_scale_inv, ctx.block_size, grad_output.dtype)

Turbopack: fix trailing-slash package root resolutionRust · 118 + / 10 −

Introduces 3 new declarations in turbopack/crates/turbopack-core/src/resolve/mod.rs.

Adds new framework internals rather than adjusting what was there. Tests changed with it, with code of their own.

turbopack/crates/turbopack-core/src/resolve/mod.rs ↗ · 6 files

@@ -3908,6 +3914,108 @@ mod tests {         .await;     } +    #[rstest::rstest]+    #[case::main(rcstr!("package").into(), r#"{"main":"./main.js"}"#, vec![("package", "main.js")])]+    #[case::main_trailing_slash(rcstr!("package/").into(), r#"{"main":"./main.js"}"#, vec![("package/", "main.js")])]+    #[case::index(rcstr!("package").into(), "{}", vec![("package", "index.js")])]+    #[case::index_trailing_slash(rcstr!("package/").into(), "{}", vec![("package/", "index.js")])]+    #[case::exports(rcstr!("package").into(), r#"{"exports":"./main.js"}"#, vec![("package", "main.js")])]+    #[case::exports_trailing_slash(rcstr!("package/").into(), r#"{"exports":"./main.js"}"#, vec![])]+    #[case::exports_subpath(rcstr!("package/subpath.js").into(), r#"{"exports":{"./subpath.js":"./main.js"}}"#, vec![("package/subpath.js", "main.js")])]+    #[case::dynamic_subpath(+        Pattern::concat([rcstr!("package/").into(), Pattern::Dynamic, rcstr!(".js").into()]),+        r#"{"main":"./main.js"}"#,+        vec![("package/index.js", "index.js"), ("package/main.js", "main.js"), ("package/subpath.js", "subpath.js")]+    )]+    #[case::dynamic_trailing_slash(+        Pattern::concat([rcstr!("package/").into(), Pattern::Dynamic]),+        r#"{"main":"./main.js"}"#,+        vec![+            ("package/", "main.js"),+            ("package/index", "index.js"), ("package/index.js", "index.js"),+            ("package/main", "main.js"), ("package/main.js", "main.js"),+            ("package/package", "package.json"), ("package/package.json", "package.json"),+            ("package/subpath", "subpath.js"), ("package/subpath.js", "subpath.js")+        ]+    )]+    #[case::dynamic_roots(+        Pattern::Alternatives(vec![+            rcstr!("package").into(),+            Pattern::concat([rcstr!("package/").into(), Pattern::Dynamic]),+        ]),+        r#"{"main":"./main.js"}"#,

feat(asr): native CTC loss kernel over sequence-packed log probabilitiesPython · 377 + / 4 −

Introduces 11 new declarations in nemo/collections/asr/parts/triton/ctc_loss.py.

Adds new core implementation rather than adjusting what was there. Tests changed with it, with code of their own.

nemo/collections/asr/parts/triton/ctc_loss.py ↗ · 3 files

@@ -0,0 +1,337 @@+# Copyright (c) 2026, NVIDIA CORPORATION.  All rights reserved.+#+# Licensed under the Apache License, Version 2.0 (the "License");+# you may not use this file except in compliance with the License.+# You may obtain a copy of the License at+#+#     http://www.apache.org/licenses/LICENSE-2.0+#+# Unless required by applicable law or agreed to in writing, software+# distributed under the License is distributed on an "AS IS" BASIS,+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+# See the License for the specific language governing permissions and+# limitations under the License.++"""CTC loss over sequence-packed log probabilities.++The log probabilities of a packed batch are one token-flat ``(T_total, D)`` buffer,+utterance ``b`` at the rows ``[cu_seqlens[b], cu_seqlens[b + 1])``.+The kernels read that buffer and write the gradient in the same layout,+so the loss needs neither the padded ``(B, T, D)`` copy that ``torch.nn.functional.ctc_loss`` takes+nor its padded gradient.++One program per utterance walks the utterance's frames.+The forward program runs the alpha recursion over the extended label sequence+``blank, l_1, blank, l_2, ..., l_U, blank`` (``S = 2 U + 1`` states, one lane per state)+and stores every alpha row into ``(T_total, S_max)``, as the padded kernel stores its ``(B, T, S)`` alphas.+The backward program runs the beta recursion from the last frame,+forms the state posteriors from the stored alphas,+and writes each frame's gradient row into the token-flat gradient:+``exp(log_probs) - posterior`` summed per class,+which is the gradient of the padded kernel+(the gradient with respect to the logits when ``log_probs`` is a ``log_softmax`` output).+The posteriors of the blank states are reduced in registers;

[Model] Support Limite 1B - ViolettoC++ · 342 + / 0 −

Introduces 10 new declarations in src/models/limite.cpp.

Adds new runtime rather than adjusting what was there. Tests changed with it, with code of their own.

src/models/limite.cpp ↗ · 15 files

@@ -0,0 +1,252 @@+#include "models.h"++// Limite: pre-norm transformer with value embeddings, exclusive self attention (XSA),+// per-head output gates, learned residual scales and dense (MUDD) cross-layer connections.+// ref: https://github.com/paradigma-inc/limite-violetto++void llama_model_limite::load_arch_hparams(llama_model_loader & ml) {+    ml.get_key(LLM_KV_ATTENTION_LAYERNORM_RMS_EPS, hparams.f_norm_rms_eps);+    ml.get_key(LLM_KV_ATTENTION_SCALE,             hparams.f_attention_scale);+    ml.get_key(LLM_KV_ATTENTION_XSA_EPS,           hparams.f_xsa_eps, false);+    ml.get_arr(LLM_KV_FINAL_LOGIT_SIGMOID_CAPPING, hparams.final_logit_sigmoid_capping, false);++    hparams.swa_type = LLAMA_SWA_TYPE_STANDARD;+    ml.get_key(LLM_KV_ATTENTION_SLIDING_WINDOW, hparams.n_swa);+    load_swa_pattern(ml, 4);++    std::fill(hparams.mudd_tap_idx.begin(), hparams.mudd_tap_idx.end(), -1);+    ml.get_key(LLM_KV_MUDD_TAP_COUNT, hparams.n_mudd_taps, false);+    if (hparams.n_mudd_taps > 0) {+        ml.get_key(LLM_KV_MUDD_FEED_FORWARD_LENGTH, hparams.n_mudd_ff);+        ml.get_arr(LLM_KV_MUDD_TAP_INDICES,         hparams.mudd_tap_idx);+    }++    switch (hparams.n_layer()) {+        case 48: type = LLM_TYPE_1B; break;+        default: type = LLM_TYPE_UNKNOWN;+    }+}++void llama_model_limite::load_arch_tensors(llama_model_loader &) {+    LLAMA_LOAD_LOCALS;++    tok_embd   = create_tensor(tn(LLM_TENSOR_TOKEN_EMBD, "weight"), {n_embd,       n_vocab}, 0);

Expose DeleteOnce and UpdateOnce methods from StorageGo · 313 + / 11 −

Introduces 12 new declarations in staging/src/k8s.io/apiserver/pkg/storage/testing/store_tests.go.

Adds new systems design rather than adjusting what was there. Tests changed with it, with code of their own.

staging/src/k8s.io/apiserver/pkg/storage/testing/store_tests.go ↗ · 10 files

@@ -6354,3 +6354,240 @@ func runOptimisticConcurrencyOp(ctx context.Context, t *testing.T, store Interfa 		} 	} }++func RunTestDeleteOnce(ctx context.Context, t *testing.T, store storage.Interface, codec runtime.Codec) {+	mustState := func(obj runtime.Object) *storage.ObjState {+		state, err := storage.GetStateFromObject(store.Versioner(), codec, obj, true)+		require.NoError(t, err)+		return state+	}++	key, existing := testPropagateStore(ctx, t, store, &example.Pod{ObjectMeta: metav1.ObjectMeta{Name: "foo", Namespace: "test-ns"}})+	stale := existing.DeepCopy()+	stale.ResourceVersion = "999999"++	tests := []struct {+		name          string+		key           string+		origState     *storage.ObjState+		expectError   bool+		expectSuccess bool+		expectOut     *example.Pod+		expectStored  *example.Pod+	}{+		{+			name:          "conflicts on stale revision",+			key:           key,+			origState:     mustState(stale),+			expectSuccess: false,+			expectOut:     &example.Pod{},+			expectStored:  existing,+		},+		{