Update model card (README) and tidy inference scaffolding

- README: rewrite as a Nemotron-TwoTower model card following the
Nemotron-3-Nano format (architecture diagram, generation modes,
training methodology, usage). Benchmark per-task numbers are
placeholders pending the released-checkpoint evaluation.
- inference.py: remove unused --trace-context-layers/--trace-denoiser-layers
flags (set but never read).
- modeling_nemotron_twotower.py: tidy the fp32-scan comment.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

README.md

@@ -44,11 +44,15 @@ track_downloads: true
 # Nemotron-TwoTower-30B-A3B-Base-BF16
 
 <div align="center" style="line-height: 1;">
-<a href="https://arxiv.org/abs/2512.20848" target="_blank" style="margin: 2px;">
-    <img alt="Paper" src="https://img.shields.io/badge/📝Paper-Read Now!-536af5?color=76B900&logoColor=white" style="display: inline-block; vertical-align: middle;"/>
+<!-- TODO: update paper link/badge once the Nemotron-TwoTower technical report is public -->
+<a href="https://huggingface.co/collections/nvidia/nemotron-twotower" target="_blank" style="margin: 2px;">
+    <img alt="Paper" src="https://img.shields.io/badge/📝Paper-Coming Soon-536af5?color=76B900&logoColor=white" style="display: inline-block; vertical-align: middle;"/>
 </a>
 <a href="https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16" target="_blank" style="margin: 2px;">
-    <img alt="Base Model" src="https://img.shields.io/badge/🏗️Base_Model-Single_Tower-76B900?logoColor=white" style="display: inline-block; vertical-align: middle;"/>
+    <img alt="Backbone" src="https://img.shields.io/badge/🏗️Backbone-Nemotron_3_Nano_30B--A3B-76B900?logoColor=white" style="display: inline-block; vertical-align: middle;"/>
+</a>
+<a href="https://huggingface.co/collections/nvidia/nemotron-twotower" target="_blank" style="margin: 2px;">
+    <img alt="Collection" src="https://img.shields.io/badge/🤗Collection-Nemotron--TwoTower-76B900?logoColor=white" style="display: inline-block; vertical-align: middle;"/>
 </a>
 </div>
 
@@ -66,44 +70,72 @@ track_downloads: true
 
 **Data Freshness:** The pre-training data has a cutoff date of June 25, 2025.
 
+Nemotron-TwoTower-30B-A3B-Base-BF16 is a **block-wise autoregressive diffusion** language model built on the [NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16](https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16) backbone. It generates text by iteratively denoising blocks of tokens in parallel rather than one token at a time.
+
+This model is ready for commercial use.
+
 ## Description
 
-Nemotron-TwoTower-30B-A3B-Base-BF16 is a **two-tower** variant of [NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16](https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16). It uses the same Mamba2-Transformer Hybrid MoE architecture but splits the model into two separate towers:
+Nemotron-TwoTower uses two towers:
 
-- **Context Tower** — processes the prompt and generated context (causal, autoregressive)
-- **Denoiser Tower** — generates new tokens given the context (can be used for AR or block-wise diffusion)
+- **Context tower (AR / context)** — a frozen causal, autoregressive tower that processes the clean prompt and all previously committed tokens once, producing the per-layer KV cache (attention) and final Mamba-2 states.
+- **Denoiser tower (diffusion / denoiser)** — a trainable tower that generates a block of tokens at a time via mask diffusion, refining noisy blocks with bidirectional in-block attention, layer-aligned cross-attention to the context tower, and context-seeded Mamba states.
 
-Both towers share the same architecture (52 layers, `MEMEM*EMEMEM*...` hybrid pattern) but have **independently trained weights**. The context tower is initialized from the single-tower base model and frozen; the denoiser tower is trained to predict next tokens given the context tower's representations.
+Both towers are copies of the same 52-layer hybrid Mamba-2 / attention / MoE backbone; only the diffusion/denoiser tower is trained, and the AR/context tower stays frozen. The denoiser is trained on **~2.1T tokens** (the backbone was pretrained on 25T tokens). At the default operating point, Nemotron-TwoTower retains **98.7%** of the autoregressive baseline's aggregate benchmark quality and provides **2.42×** the AR baseline's wall-clock generation throughput.
 
-### Two-Tower Generation Modes
+### What is Nemotron?
 
-| Mode | Description | Tokens/step | API |
-|------|-------------|-------------|-----|
-| **Mask Diffusion** | Block-wise iterative denoising with confidence-based unmasking (flagship two-tower mode). | up to `block_size` | `generate_mask_diffusion()` |
-| **Mock-AR** | Two-tower autoregressive. Context tower builds cache, denoiser predicts next token. | 1 | `generate_mock_ar()` |
-| **AR** | Standard autoregressive via `generate()`. Uses context tower only (single GPU). | 1 | `generate()` |
+NVIDIA Nemotron™ is a family of open models with open weights, training data, and recipes, delivering leading efficiency and accuracy for building specialized AI agents.
 
-### What is Two-Tower?
+## Architecture
 
-The two-tower architecture decouples "understanding context" from "generating tokens" into separate networks:
+```
+      AR / Context Tower            Diffusion / Denoiser Tower
+
+       clean token blocks                noisy token blocks
+               │                                 │
+       ┌───────▼───────┐                 ┌───────▼───────┐
+       │   Embedding   │                 │   Embedding   │
+       └───────┬───────┘                 └───────┬───────┘
+               │                                 │
+       ┌───────▼───────┐    KV + Mamba   ┌───────▼───────┐
+       │ Mamba-2/Attn  │─────states─────▶│ Mamba-2/Attn  │
+       └───────┬───────┘                 └───────┬───────┘
+               │                                 │
+       ┌───────▼───────┐                 ┌───────▼───────┐
+       │      MoE      │                 │      MoE      │
+       └───────┬───────┘                 └───────┬───────┘
+               │                                 │
+       ┌───────▼───────┐                 ┌───────▼───────┐
+       │  Output Head  │                 │  Output Head  │
+       └───────┬───────┘                 └───────┬───────┘
+               │                                 │
+         logits / loss                     logits / loss
+          (optional)
+```
 
-- **Context Tower** runs causally over the prompt and all previously committed tokens, producing the layer-aligned KV cache (attention) and Mamba states that the denoiser conditions on.
-- **Denoiser Tower** generates a *block* of tokens at once. Within a block it is **bidirectional** (every position attends to the whole noisy block + the full causal context); across blocks it is causal via the context cache.
+The AR/context tower (left) runs causally over clean token blocks and exposes, at every layer, the attention KV cache and the Mamba-2 conv/SSM boundary states. The diffusion/denoiser tower (right) consumes a noisy block; at each layer it cross-attends to the corresponding layer of the context tower (KV) and seeds its Mamba-2 layer from the corresponding context Mamba state.
 
-This enables **block-wise parallel generation** — the denoiser fills `block_size` masked positions per block and commits the most confident ones each step, so a block resolves in a handful of denoising steps rather than `block_size` autoregressive steps.
+### Two-Tower Generation Modes
 
-### Mask Diffusion: how it works
+| Mode | Description | Tokens / step | API |
+|------|-------------|---------------|-----|
+| **Mask Diffusion** | Diffusion/denoiser mode: block-wise iterative denoising with confidence-based unmasking. | up to `block_size` | `generate_mask_diffusion()` |
+| **Mock-AR** | Two-tower **autoregressive**: AR/context tower builds the cache, diffusion/denoiser predicts the next token. | 1 | `generate_mock_ar()` |
+| **AR** | Standard **autoregressive** generation using the AR/context tower only (single GPU). | 1 | `generate_ar()` |
 
-Generation proceeds block by block. For each new block of `block_size` positions:
+### How mask diffusion works
+
+Generation is **block-wise autoregressive**: the AR/context tower encodes the prompt once, then the diffusion/denoiser fills one block of `block_size` positions at a time. For each new block:
 
 1. Initialize the block as all `[MASK]` tokens (`mask_token_id`).
-2. For `steps_per_block` iterations:
-   - Compute the diffusion timestep `t` = current masked fraction of the block, and feed it to the **time-conditioned denoiser** (PixArt-α adaLN-single modulation on every denoiser layer).
-   - Run the denoiser over the whole block (bidirectional self-attention + cross-attention to the context cache; Mamba chunk-scan seeded from the context state).
-   - Constrain to `p(x₀ | xₜ)` (mask token forbidden; already-decoded positions fixed), then **commit** the highest-confidence positions (all above `confidence_threshold`, with a floor that guarantees completion in `steps_per_block`) and re-mask the rest.
-3. Append the resolved block to the context, extend the context cache, and continue.
+2. For `steps_per_block` denoising iterations:
+   - Compute the diffusion timestep `t` = current masked fraction of the block, and feed it to the **time-conditioned denoiser** (adaLN-single modulation — a global MLP maps `t` to per-layer scale/shift/gate, PixArt-α style).
+   - Run the diffusion/denoiser over the whole block (bidirectional in-block self-attention + layer-aligned causal cross-attention to the AR/context cache; Mamba-2 chunk-scan seeded from the context state).
+   - Constrain to `p(x₀ | xₜ)` (mask token forbidden; already-decoded positions fixed), then **commit** the high-confidence positions (all above `confidence_threshold`, with a floor that guarantees completion within `steps_per_block`) and re-mask the rest (**confidence unmasking**).
+3. Commit the resolved block, advance the AR/context tower over it to update the KV + Mamba caches, and continue with the next block.
 
-This model is ready for commercial use.
+Each step predicts all masked positions in parallel and commits the confident subset, so multiple tokens may be committed per step.
 
 ## License/Terms of Use
 
@@ -111,27 +143,54 @@ GOVERNING TERMS: Use of this model is governed by the [NVIDIA Nemotron Open Mode
 
 ## Benchmark Evaluations
 
-*Benchmark scores will be added in a future update.*
+Default operating point: **confidence unmasking**, threshold `γ = 0.8`, block size `S = 16`, BF16 on 2×H100 GPUs. At this point Nemotron-TwoTower retains **98.7%** of the AR baseline's aggregate benchmark quality and reaches **2.42×** the AR baseline's wall-clock generation throughput. Lowering the confidence threshold increases the tokens committed per step and the throughput, with reduced quality.
+
+Per-task results below compare the autoregressive backbone (AR/context baseline) against Nemotron-TwoTower (diffusion/denoiser decoding). <!-- TODO: fill in final released-checkpoint numbers -->
+
+| Task | NVIDIA-Nemotron-3-Nano-30B-A3B-Base (AR baseline) | Nemotron-TwoTower-30B-A3B-Base (diffusion) |
+| :---- | :---- | :---- |
+| **General Knowledge** | | |
+| MMLU (5-shot, acc) | 78.56 | _To be filled_ |
+| MMLU-Pro (5-shot, CoT EM) | 65.05 | _To be filled_ |
+| **Code** | | |
+| HumanEval (0-shot) | 78.05 | _To be filled_ |
+| MBPP-Sanitized (3-shot) | 75.49 | _To be filled_ |
+| **Math** | | |
+| GSM8K (8-shot, acc) | 92.34 | _To be filled_ |
+| MATH-500 (4-shot) | 78.63 | _To be filled_ |
+| **Multilingual** | | |
+| MGSM (8-shot, avg acc) | 83.00 | _To be filled_ |
+| **Aggregate** | | |
+| Quality retained (% of AR baseline) | 100% | **98.7%** |
+| Generation throughput (× AR baseline) | 1.0× | **2.42×** |
+
+<!-- TODO: confirm AR-baseline column values and the evaluation harness/configs for the diffusion column before release. -->
 
 ## Model Architecture
 
-- **Architecture Type:** Two-Tower Mamba2-Transformer Hybrid Mixture of Experts (MoE)
+- **Architecture Type:** Two-Tower Block-Diffusion over a Mamba2-Transformer Hybrid Mixture of Experts (MoE) backbone
 - **Network Architecture:** Nemotron Hybrid MoE (Two-Tower)
-- **Number of model parameters:** ~60B total (30B context tower + 30B denoiser tower)
-- **Active parameters per token:** ~3B per tower (~6B total for two-tower generation)
-- **Number of layers:** 52 per tower
-- **Layer pattern:** `MEMEM*EMEMEM*EMEMEM*EMEMEM*EMEMEM*EMEMEMEM*EMEMEMEME`
-  - `M` = Mamba2, `*` = Attention, `E` = MoE, `-` = MLP
+- **Backbone:** [NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16](https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16)
+- **Layers per tower:** 52 — **23 Mamba-2**, **6 self-attention**, **23 MoE**
+- **Number of model parameters:** ~60B total (30B AR/context tower + 30B diffusion/denoiser tower); the released checkpoint ships both towers
+- **Active parameters per token:** ~3B per tower (≈6B total when both towers run during two-tower diffusion generation)
+- **Denoiser-only modifications vs. the backbone:**
+  - **Bidirectional in-block attention** — noisy tokens attend bidirectionally within the current block, causally to past clean blocks (no added parameters).
+  - **Layer-aligned cross-attention** — denoiser layer *i* attends to context-tower layer *i*'s KV.
+  - **Context-seeded Mamba-2** — denoiser Mamba layers seed their initial conv/SSM state from the corresponding context Mamba state (causal; the bidirectional-Mamba variant is not used).
+  - **adaLN-single time conditioning** — the diffusion timestep `t` modulates every denoiser layer (≈1.5M added parameters; replicated per tensor-parallel rank).
 
 ## Training Methodology
 
-The two-tower model is trained in two stages:
+Nemotron-TwoTower is produced by adapting a pretrained autoregressive backbone into a block-wise diffusion generator — **only the diffusion/denoiser tower is trained; the AR/context tower is frozen.**
 
-1. **Stage 1: Base Pre-Training** — The single-tower [NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16](https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16) is pre-trained with standard next-token prediction (~25T tokens).
+- **Stage 1 — Backbone pre-training (AR).** The single-tower [NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16](https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16) is pre-trained from scratch with next-token prediction (~25T tokens).
+- **Stage 2 — Two-tower denoiser training (diffusion).** Both towers are initialized from the same backbone checkpoint. The AR/context tower is frozen; the diffusion/denoiser tower is trained under a **masked-diffusion** objective (mean negative log-likelihood over masked positions), conditioned on the context tower's per-layer KV cache and Mamba boundary states. Training follows the backbone's two-stage data curriculum (broad phase-1 blend → higher-quality phase-2 blend), over **~2.1T tokens** total.
 
-2. **Stage 2: Two-Tower Training** — The model is duplicated into context + denoiser towers. The context tower is frozen; the denoiser tower is trained with the two-tower objective where it learns to predict tokens given context tower representations.
+The released checkpoint is trained in three stages: phase-1 adaptation at block size `S=32`, phase-2 continuation at `S=32`, and a final phase-2 continuation at `S=16` (the default sampling block size).
 
-Software used for training: [Megatron-LM](https://github.com/NVIDIA/Megatron-LM)
+- **Precision:** BF16. **Optimizer:** AdamW with a Warmup-Stable-Decay schedule (peak LR `1e-4`, final LR `1e-6`), reset at phase boundaries.
+- **Software used for training:** [Megatron-LM](https://github.com/NVIDIA/Megatron-LM)
 
 ## Input
 
@@ -147,14 +206,17 @@ Software used for training: [Megatron-LM](https://github.com/NVIDIA/Megatron-LM)
 - **Output Parameters:** One-Dimensional (1D): Sequences
 - **Maximum output size:** 128K tokens
 
+Our AI models are designed and optimized to run on NVIDIA GPU-accelerated systems. By leveraging NVIDIA's hardware (e.g. GPU cores) and software frameworks (e.g., CUDA libraries), the model achieves faster training and inference times compared to CPU-only solutions.
+
 ## Software Integration
 
-- Supported Hardware: NVIDIA H100-80GB, NVIDIA A100 (requires 2 GPUs for full two-tower inference, ~59GB per GPU)
-- Operating System(s): Linux
+- **Runtime Engine(s):** HuggingFace Transformers (with `trust_remote_code=True`)
+- **Supported Hardware Microarchitecture Compatibility:** NVIDIA H100-80GB, NVIDIA A100 (full two-tower diffusion inference uses **2 GPUs**, ~59GB per GPU for BF16 weights)
+- **Operating System(s):** Linux
 
 ### Use it with Transformers
 
-The snippet below shows how to use this model with HuggingFace Transformers. **Two-tower inference requires 2 GPUs** (~59GB per GPU for bf16 weights); the towers are placed on separate devices.
+Full **two-tower diffusion** inference places the AR/context tower and the diffusion/denoiser tower on separate GPUs.
 
 ```python
 import torch
@@ -168,20 +230,20 @@ model = AutoModelForCausalLM.from_pretrained(
     trust_remote_code=True,
 )
 
-# Context tower -> GPU 0, denoiser tower -> GPU 1
+# AR/context tower -> GPU 0, diffusion/denoiser tower -> GPU 1
 model.place_towers_on_devices("cuda:0", "cuda:1")
 model.eval()
 
 prompt = "France is a country "
 inputs = tokenizer(prompt, return_tensors="pt").to("cuda:0")
 
-# Flagship mode: block-wise mask diffusion
+# Mask-diffusion generation (two-tower)
 outputs = model.generate_mask_diffusion(
     inputs["input_ids"],
     max_new_tokens=128,
     block_size=16,            # tokens generated per block
     steps_per_block=16,       # denoising iterations per block
-    mask_token_id=3,          # <mask>
+    mask_token_id=3,          # [MASK]
     temperature=0.1,
     confidence_threshold=0.8, # commit positions above this confidence each step
     eos_token_id=tokenizer.eos_token_id,
@@ -189,7 +251,7 @@ outputs = model.generate_mask_diffusion(
 print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True))
 ```
 
-**Mock-AR** (two-tower, one token per step):
+**Mock-AR** (two-tower autoregressive, one token per step):
 
 ```python
 outputs = model.generate_mock_ar(
@@ -199,48 +261,52 @@ outputs = model.generate_mock_ar(
 print(tokenizer.decode(outputs[0], skip_special_tokens=True))
 ```
 
-**AR-only** (single GPU, context tower only — load with `.cuda()` instead of `place_towers_on_devices`):
+**AR-only** (single GPU, AR/context tower only — load with `.cuda()` instead of `place_towers_on_devices`):
 
 ```python
-outputs = model.generate(**inputs, max_new_tokens=128, do_sample=False)
+outputs = model.generate_ar(
+    inputs["input_ids"], max_new_tokens=128, temperature=0.0,
+    eos_token_id=tokenizer.eos_token_id,
+)
 print(tokenizer.decode(outputs[0], skip_special_tokens=True))
 ```
 
 ## Model Version(s)
 
-- v1.1 — Block-wise **mask-diffusion** generation enabled (time-conditioned denoiser, bidirectional in-block attention, chunk-scan Mamba); AR and mock-AR also supported.
-- v1.0 — Two-tower AR (mock-AR) checkpoint
+- **v1.1** — Block-wise **mask-diffusion** generation enabled (time-conditioned diffusion/denoiser, bidirectional in-block attention, context-seeded chunk-scan Mamba-2); AR and mock-AR also supported.
+- **v1.0** — Two-tower AR (mock-AR) checkpoint.
 
 # Training, Testing, and Evaluation Datasets
 
-This model is trained on the same data as [NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16](https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16). See the [base model card](https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16#training-testing-and-evaluation-datasets) for full dataset details.
+The diffusion/denoiser tower is trained on the same data sources as the [NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16](https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16) backbone (a ~2.1T-token subset of the backbone's two-phase blend). See the [base model card](https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16#training-testing-and-evaluation-datasets) for the full dataset listing.
 
-**Data Modality:** Text
-**The total size:** 10,648,823,153,919 Tokens (Stage 1 pre-training)
-**Total number of datasets:** 141
-**Data Collection Method by dataset:** Hybrid: Automated, Human, Synthetic
+- **Data Modality:** Text
+- **Data Collection Method by dataset:** Hybrid: Automated, Human, Synthetic
+- **Labeling Method by dataset:** Not applicable (self-supervised mask-diffusion objective)
 
 ## Inference
 
-- Engines: HF Transformers (with `trust_remote_code=True`)
-- Test Hardware: 2x NVIDIA A100 80GB or 2x NVIDIA H100 80GB
+- **Engine(s):** HuggingFace Transformers (with `trust_remote_code=True`)
+- **Test Hardware:** 2× NVIDIA A100 80GB or 2× NVIDIA H100 80GB (two-tower diffusion); 1× 80GB GPU sufficient for AR-only mode
 
 ## Ethical Considerations
 
-NVIDIA believes Trustworthy AI is a shared responsibility and we have established policies and practices to enable development for a wide array of AI applications. When downloaded or used in accordance with our terms of service, developers should work with their internal model team to ensure this model meets requirements for the relevant industry and use case and addresses unforeseen product misuse.
+NVIDIA believes Trustworthy AI is a shared responsibility and we have established policies and practices to enable development for a wide array of AI applications. When downloaded or used in accordance with our [Trustworthy AI terms of service](https://www.nvidia.com/en-us/agreements/trustworthy-ai/terms/), developers should work with their internal model team to ensure this model meets requirements for the relevant industry and use case and addresses unforeseen product misuse.
 
-For more detailed information on ethical considerations for this model, please see the Model Card++ [Bias](bias.md), [Explainability](explainability.md), [Safety](safety.md), and [Privacy](privacy.md) Subcards.
+For more detailed information on ethical considerations for this model, please see the Model Card++ [Bias](bias.md), [Explainability](explainability.md), and [Privacy](privacy.md) Subcards.
 
 Please report security vulnerabilities or NVIDIA AI Concerns [here](https://www.nvidia.com/en-us/support/submit-security-vulnerability/).
 
 ## Citation
 
+<!-- TODO: authors omitted for now; fill in arXiv id / venue / year when the report is public. -->
+
 ```
-@misc{nvidia_nemotron_nano_v3_2025,
-  title  = {{Nemotron 3 Nano}: Open, Efficient Mixture-of-Experts Hybrid {Mamba}-{Transformer} Model for {Agentic} Reasoning},
+@misc{nvidia_nemotron_twotower_2026,
+  title  = {{Nemotron-TwoTower}: Diffusion Language Modeling with Pretrained Autoregressive Context},
   author = {{NVIDIA}},
-  year   = {2025},
-  url    = {https://arxiv.org/abs/2512.20848},
+  year   = {2026},
+  url    = {https://huggingface.co/collections/nvidia/nemotron-twotower},
   note   = {Technical report}
 }
 ```

inference.py

@@ -43,8 +43,6 @@ parser.add_argument("--confidence-threshold", type=float, default=0.9)
 parser.add_argument("--deterministic", action="store_true")
 parser.add_argument("--seed", type=int, default=42)
 parser.add_argument("--print-diffusion-steps", action="store_true")
-parser.add_argument("--trace-context-layers", action="store_true")
-parser.add_argument("--trace-denoiser-layers", action="store_true")
 args = parser.parse_args()
 prompt = args.prompt if args.prompt is not None else (args.prompt_arg or "France is a country ")
 
@@ -75,8 +73,6 @@ else:
     model.cuda()
 
 model.eval()
-model.trace_context_layers = args.trace_context_layers
-model.trace_denoiser_layers = args.trace_denoiser_layers
 # Build the request list. A --prompt-file (jsonl, one {"text": ...} per line,
 # same format mcore consumes) runs as multiple Requests i/N; otherwise the
 # single positional/--prompt is the lone request.

modeling_nemotron_twotower.py

@@ -557,8 +557,8 @@ class NemotronHTwoTowerForCausalLM(NemotronHPreTrainedModel, GenerationMixin):
         # Run the SSM scan in fp32. With a long context the seeded SSM state gets
         # large (O(1e3)+); the bf16 chunk-scan then overflows to NaN, and because
         # the Triton kernel's reductions are not bit-deterministic this strikes
-        # nondeterministically (a NaN on a block's first/all-masked step force-
-        # commits a garbage token, e.g. "katalog"/"hips", and wrecks the answer).
+        # nondeterministically (a NaN on a block's first/all-masked step makes
+        # every confidence NaN and force-commits an arbitrary token).
         # The scan spans only one block (<=16 tokens) so fp32 is essentially free,
         # and it is strictly more accurate. Cast back before the gated norm.
         _y_dtype = z.dtype