AI papers — 2026-07-23

Problem: Full-parameter post-training of trillion-parameter-scale Mixture-of-Experts (MoE) LLMs on non-GPU (Ascend NPU) hardware suffers from severe memory pressure, non-overlapped communication overhead, and inefficient kernel execution, while domain-specific post-training for complex Operations Research (OR) modeling tasks remains largely unexplored.

Method: The authors build "SLAI T-Rex" on an Ascend CloudMatrix384 SuperPOD (Ascend 910C NPUs, 64GB HBM/device), training DeepSeek-V4-Pro (1.6T parameters, hybrid sparse attention + MoE) with a hierarchical optimization stack: expert-tensor parallelism (ETP, Megatron-LM "Parallel Folding") with TP=2 for attention and ETP=1 for MoE, Virtual Pipeline Parallelism (VPP, pipeline degree 8) chosen over DualPipeV, asynchronous all-to-all MoE dispatch/combine with shared-expert forward overlapped against the before_ep_alltoall sync stall, and a double-buffered swap AdamW optimizer that chunk-pipelines host-device transfers. A kernel-optimization agent, AuraKernel, uses OR-based tiling search plus a modify-verify-profile loop (K-Search) to retune AscendC kernels (sparse-attention backward, lightning-indexer gradient, RMS-norm) and fuses fragmented eager/Triton chains (mHC pre/post-projection, limited SwiGLU, RoPE) into AscendC kernels. On top of this infrastructure, they run OR-oriented Continued Pre-Training (CPT, ~100K-document domain-dominant mixture of OR/math/code/general text via MindSpeed/TorchTitan-NPU) followed by Supervised Fine-Tuning (SFT) on DeepSeek-V4-Flash using a self-distilled data flywheel (L1 Canonical IR → L2 Semantic IR → L3 Synthetic IR, rendered into DP/DT/DPS problem formats with Gurobi-based answers), contract-aware Cleaner/Reviewer/Diagnostic-Resolver cleaning with chain-of-thought (Clean-CoT) enhancement, and a two-stage progressive SFT (Stage I solver-API alignment at lr=5e-7, Stage II full OR modeling SFT at lr=1e-6 with 10-15% general-instruction data anchoring).

Key results:

• Infrastructure optimization raises Model FLOPs Utilization (MFU) from 11.67% to 34.22% on DeepSeek-V4-Pro training, a 2.93× improvement over the open-source baseline recipe.
• AuraKernel speeds up individual kernels up to 11.90× (RMS-norm forward) and 3.42× (RMS-norm backward), with sparse-attention backward improved 1.21-1.24× and lightning-indexer gradient 1.16-1.21×; across 14 Triton-Ascend operators the average speedup is 2.06×.
• Kernel fusion/rewrite yields module-level speedups such as 3.03× (mHC pre-projection), 8.86× (limited SwiGLU forward), and 3.54× (RoPE backward); Triton-to-AscendC rewrites reach 7.48-7.55× on RMS-norm.
• A 50K-sample SFT run on 8 nodes/128 Ascend 910C NPUs completes 800/800 steps with 0 skipped/NaN iterations, converging to lm loss ≈0.079 and mtp_1 loss ≈0.093.
• Matched CPT-to-SFT transfer: direct SFT raises B4O-Feasible from 60.47% to 65.93% and B4O-ORGEval from 34.26% to 48.73%; CPT-initialized SFT further raises these to 71.22% and 59.39% respectively (+5.29pp and +10.66pp over SFT-only).
• The final CPT+SFT model (SLAI T-Rex) achieves 71.81% average zero-shot Pass@1 across four OR benchmarks, beating GPT-5.4-Mini by 3.98pp and base DeepSeek-V4-Flash by 11.27pp, while general benchmarks (MMLU, GSM8K, MATH, HumanEval, etc.) show only minor fluctuations (+0.9 to -1.8pp) versus base, indicating no catastrophic forgetting.
• SFT data scaling is non-monotonic: raw SFT-50K underperforms SFT-10K on OptiBench (58.68% vs 62.67%), whereas cleaning the 10K set (Clean-CoT) improves NL4OPT by 5.27pp, OptiBench by 1.50pp, B4O-Feasible by 0.86pp, and B4O-ORGEval by 1.52pp over uncleaned SFT-10K.

Why it matters / caveats: The work claims to be among the first publicly documented full-stack studies of full-parameter post-training for a trillion-parameter-class MoE model on Ascend (SIMD) NPU hardware rather than GPU/TPU clusters, and shows a reproducible CPT-SFT recipe for injecting solver-grounded OR reasoning into an LLM. The authors explicitly note the post-training experiments were conducted only on the smaller DeepSeek-V4-Flash (not the 1.6T DeepSeek-V4-Pro), leaving scalability to Pro as future work, and they acknowledge that cleaning/CoT enhancement does not fix all error types (e.g., nonlinear/Gurobi-form errors on OptiBench actually increased), and that pure-OR CPT data mixtures (without general data) cause 10-15 point drops on general benchmarks, motivating their balanced-mixture design.

Problem: Autoregressive video diffusion models trained with Self Forcing (which conditions on self-generated rollout history) never receive gradient supervision on how earlier generated latents are written into the historical key-value cache, causing identity, layout, and temporal drift to accumulate during long-horizon video extrapolation — a gap the paper calls the "historical context-gradient gap."

Method: The paper proposes Self Gradient Forcing (SGF), a two-pass training strategy built on top of a causal DiT with a sink-plus-FIFO KV cache policy. Pass 1 performs a no-gradient serial autoregressive rollout (matching inference) and, at a sampled denoising exit step, records the self-generated context latents and noisy input latents. Pass 2 discards the rollout cache and, in parallel, reconstructs the same exit-step computation using FlexAttention with a compiled static block-sparse causal mask: the recorded context is fed as stop-gradient clean-latent input, but the model re-encodes it at the clean context timestep (tctx=0) with gradients enabled through the context K/V projections and future-to-context causal attention, training with the distribution-matching distillation (DMD) loss so future losses backpropagate into clean-timestep K/V-writing computation without full rollout backpropagation. Training is evaluated across frame-wise (sink 4, window 21, FIFO 16, chunk 1) and chunk-wise (sink 3, window 12, FIFO 6, chunk size 3) generation, under Causal ODE, Causal CD, and TF initializations, all using the same 5-second training window.

Key results:

• On 240s frame-wise TF-init extrapolation, SGF improves subject consistency from 0.965 to 0.972 and background consistency from 0.965 to 0.968 versus Self Forcing (Table 1).
• On 60s chunk-wise TF-init generation, SGF raises aesthetic quality from 0.582 to 0.654 and background consistency from 0.947 to 0.971 (Table 2).
• A blind GSB human preference study with over 1,900 paired judgments across 10 matched comparisons found all scores positive for SGF, e.g., 48.7% preference (frame-wise, 240s, TF init) and 44.9% (chunk-wise, 240s, TF init) (Table 3).
• A direct differentiable-cache training baseline ran out of memory (OOM), whereas SGF added only modest overhead versus frozen-cache Self Forcing: peak memory 87.01GB vs 79.01GB, stable memory actually decreased (63.73GB vs 79.01GB), and time per 5 training steps rose from 10.39s to 11.71s (Table 4).
• Models trained with only a 5-second window were able to extrapolate to videos lasting up to 240 seconds (several minutes).

Why it matters / caveats: SGF demonstrates that recovering gradient supervision for KV-cache writing (previously discarded in frozen-cache Self Forcing) substantially improves long-horizon consistency without the prohibitive memory cost of a fully differentiable cache, and is presented as orthogonal to and combinable with other forcing-based improvements. A noted caveat is that Self Forcing sometimes scores higher on "dynamic degree," but the paper attributes this to incoherent large motion from scene jumps and broken camera geometry rather than genuinely better motion quality; the conclusion also notes future work could combine SGF with stronger initialization, long-context tuning, retrieval, and cache-compression techniques, implying these were not explored here.

Problem: Existing document-retrieval evaluation systems (e.g., TREC-DL, BEIR, MTEB, RAGAS, ARES, BRIGHT, RA-nWG) score documents independently and aggregate via nDCG, ignoring inter-document interactions such as redundancy, conflict, and complementarity, so they cannot explain what makes one retrieved document set better than another for LLM-based generation.

Method: The authors build SetwiseEvalKit, a three-level (document-level, set-level, global-level), nine-dimension rubric benchmark (Relevance, Authenticity, Quality, Complementarity, Redundancy, Conflict, Completeness, Density, Reachability) covering short-form (multi-hop QA: HotpotQA, 2WikiMultihopQA, MuSiQue, Bamboogle) and long-form (ResearchQA via the DR.Tulu-8B search agent over Google Search, wrapped as MCP tools) scenarios, comprising ~28K rubrics generated by a multi-model pipeline (GPT 5.1 and Gemini 3.1-Pro-Preview generate candidates, DeepSeek-V4 Pro aggregates/filters them) and scored 0–4 by DeepSeek-V4 Pro as LLM-judge. On top of this, they propose Rubric4Setwise, a training-free method using Qwen3-8B as a reasoning backbone that selects a subset S* = argmax f(S; q, R) via chain-of-thought prompting, with the subset size adaptively determined by rubric satisfaction rather than fixed in advance. They evaluate 12 rerankers (adhoc: BGE-Reranker-Large, MonoT5-3B, RankT5-3B, RankLlama-7B, RankVicuna-7B, RankZephyr-7B, Setwise-7B; reasoning-enhanced: Rank1-7B, Rearank-7B, ReasonRank-7B; setwise: SetR-8B, Rank4Gen-8B) plus BM25-only/Google-Search-only baselines, using Llama-3.1-8B-Instruct as the short-form downstream generator.

Key results:

• Rubric coverage scores correlate strongly with downstream generation quality (Pearson r = 0.92, p = 0.0013), validating the benchmark.
• Even the best reranker achieves no more than 45% overall rubric coverage, with cross-document coordination dimensions (Complementarity, Completeness) universally weak.
• In the short-form scenario, Rubric4Setwise achieves the best EM (26.10, +7.47 over no reranking) and F1 (29.32, +8.22), beating the second-best SetR by 0.97 on EM and 0.62 on F1, while using only 2.66 documents on average versus a fixed top-5 for conventional rerankers.
• In the long-form scenario, Rubric4Setwise achieves the highest LLM-judge score (70.57), outperforming ReasonRank and Rearank by 2.42 and 2.22 points respectively, using fewer documents (20.52 vs. 29.23 for SetR) and fewer search rounds (4.52 vs. 4.73).
• Setwise reranking methods dominate in the short-form scenario, but reasoning-enhanced methods (ReasonRank, Rearank) lead in the long-form scenario; no single existing reranker maintains top performance across both settings, while Rubric4Setwise does.

Why it matters / caveats: The work reframes retrieval evaluation and optimization around document-set-level (not per-document) rubric criteria, closing the loop from evaluation to selection and showing generation gains with fewer documents and search rounds. The authors explicitly caveat that Rubric4Setwise operates under an "oracle setting" (rubrics generated using reference answers), so its results represent an empirical upper bound rather than a fully practical, reference-free method; they note distilling rubric preferences into trainable rewards as a needed next step for rerankers to internalize this signal without access to reference answers.

Problem: Current vision-language benchmarks fail to measure whether multimodal large language models (MLLMs) perform "active observation" — the human-like iterative loop of returning to an image to form, test, and refine hypotheses rather than relying on a single static glance.

Method: The authors introduce ActiveVision, a benchmark of 17 task generators grouped into three cognitive families (Distributed Scanning, Sequential Traversal, Visual Attribute Transfer), each built via a two-stage pipeline: a deterministic Matplotlib procedural scaffold defines exact ground-truth geometry (positions, counts, topology), which GPT-image-2 then re-renders into a photorealistic image while preserving that geometry. Evaluation uses exact-match accuracy on a fixed 85-item split (5 instances × 17 tasks) with pure chain-of-thought prompting (single user message, no system prompt, answer wrapped in <answer> tags) across frontier MLLMs (GPT-5.5, Claude Fable 5, Claude Opus 4.7/4.8, Gemini 3.1 Pro, Gemini 3.5 Flash) at every exposed reasoning-effort tier, plus an agentic ablation using three autonomous coding agents (Codex/GPT-5.5, Claude Code/Opus 4.8, Claude Code/Fable 5) that write and execute their own vision code at xhigh effort in sandboxes containing only the image and question.

Key results:

• Best model overall: GPT-5.5 at xhigh reasoning effort solves only 9/85 items (10.6%) and scores zero on 11 of 17 tasks.
• Claude Fable 5 (max effort), despite topping reasoning/coding leaderboards, solves only 3/85 items (3.5%); Claude Opus 4.8 max scores 2/85 (2.4%), Claude Opus 4.7 max 4/85 (4.7%), Gemini 3.1 Pro high 5/85 (5.9%), Gemini 3.5 Flash high 7/85 (8.2%).
• Three human participants average 96.1% (81.7/85; individual scores 97.6%, 96.5%, 94.1%), roughly nine times the best model, completing each item in about 33.6 seconds on average.
• Scaling GPT-5.5's reasoning effort from none to xhigh raises per-item API cost nearly 100-fold but improves accuracy only from 2.4% to 10.6%; a question-only (image-omitted) control scores 2.4% (2/85), similar to the "none"-effort full-input run.
• Agentic tool use narrows but does not close the gap: Claude Code with Fable 5 solves 43/85 (50.6%), Codex (GPT-5.5) 32/85 (37.6%), Claude Code with Opus 4.8 21/85 (24.7%) — yet all three score zero on Tangled Loop Counting, and agents cost $2.74–$7.63 and 12–15 minutes per item versus a human's ~0.56 minutes and no cost.
• On difference-spotting tasks, models exhibit a "same" response bias, missing 73–100% of real differences across runs while keeping false-alarm rates low (0–21%).

Why it matters / caveats: The paper argues closing this human–model gap is a prerequisite for reliable real-world deployment in domains requiring exhaustive scanning, tracing, or fine-grained comparison (radiology, connectomics, industrial inspection, robotics), since expertise in these fields largely consists of "knowing where and how to look." The authors note their images are synthetic (GPT-image-2 re-renderings rather than natural-image samples), so external validity rests on the elemental visual operations tested rather than the renderings themselves, and they caution that as models improve at image description, the property that "no short language description carries the answer" may erode, requiring future benchmark versions to be tightened.

Problem: Injecting factual knowledge into large language models reliably and at scale is an open challenge, since full fine-tuning is prohibitively expensive and both full fine-tuning and PEFT methods like LoRA suffer from catastrophic forgetting and poor out-of-distribution generalization.

Method: The paper studies train-time knowledge injection using a randomly-initialized, transformer-based hypernetwork gϕ (no causal mask, post-LayerNorm, RoPE, mean pooling over encoded facts) that maps a batch of injected facts to LoRA-style weight adaptations (rank r=4, scaling factor α=8) applied to a frozen target LLM, with LoRA adapters injected only into the second half of the target model's layers; only hypernetwork parameters ϕ are trained (AdamW, weight decay 1e-5, cosine annealing schedule) while target model weights θ stay frozen. Scaling is studied along four axes — hypernetwork depth (1–16 transformer layers), width (dmodel 32–1024, hypernetwork sizes 167M–2.8B parameters), target model size (Qwen2.5 0.5B–14B), and number of injected facts N (2–52, default N=4) — and compared against LoRA fine-tuning (r=16, α=32) and full fine-tuning baselines. Training/evaluation uses a newly constructed dataset, MegaWikiQA, built from Wikidata5M via deterministic random-walk multi-hop question generation (1–4 hops, grammar-based templates across 822 relations, 39 domains), yielding roughly 10 million examples per hop count and a filtered final training set of 1.25 million examples, with in-distribution and three OOD evaluation splits (held-out domains, GPT-4.1-rephrased questions, and multiple-choice).

Key results:

• Hypernetwork width scaling: validation loss follows Lval = 1.02·d^-0.096; OOD exponents are -0.100 (non-rephrased), -0.036 (rephrased), -0.075 (MCQ).
• Hypernetwork depth scaling: validation loss Lval = 0.677·L^-0.088; OOD exponents -0.096 (non-rephrased), -0.042 (rephrased), -0.063 (MCQ).
• Target model scaling gives the steepest exponents of all axes: validation loss Lval = 72·T^-0.226 vs. -0.088/-0.096 for depth/width; OOD non-rephrased exponent -0.184.
• Fact count scaling (N=2–52): validation loss Lval = 0.667·N^-0.080; OOD non-rephrased exponent -0.077.
• Compared to target-model scaling of LoRA fine-tuning (ID exponent -0.250) and full fine-tuning (ID exponent -0.249), the hypernetwork has a slightly flatter ID exponent (-0.226) but steeper OOD exponents across all three OOD splits (e.g., OOD MCQ: -0.171 for hypernetwork vs. -0.119 LoRA vs. -0.101 full FT), and this OOD advantage widens as target model size grows.
• At the largest configuration studied, the hypernetwork reached approximately 2.5B parameters while the target model was only 1.5B parameters.

Why it matters / caveats: The authors argue this establishes hypernetworks as a scalable, principled substrate for train-time knowledge injection that trades a marginally worse in-distribution fit for substantially better and increasingly favorable OOD generalization as target models scale, which matters most in real deployment settings. The paper itself notes caveats: the hypernetwork can become prohibitively large relative to the target model (limiting practical deployability), target-model scaling was only tested up to 14B (Qwen2.5 family) with extension to 70B+ models left open, and evaluation is limited to single-hop and shallow (up to 4-hop) multi-hop queries from Wikidata5M, with deeper multi-hop/long-horizon reasoning left as future work.

Problem: PPO-Clip (and its LLM RL derivatives like GRPO/DAPO) implicitly measures policy discrepancy using a Euclidean metric on the importance ratio, which is geometrically inconsistent with the true Riemannian (KL-divergence-induced) geometry of the policy manifold, causing overly conservative updates on rare/low-probability actions and overly aggressive updates on high-probability actions — leading to exploration collapse in LLM RL training.

Method: The paper proposes Riemannian Isometric Policy Optimization (RIPO), built on a new clipping rule called Riemannian Isometric Clip (RIC) that derives a distribution-dependent clipping boundary ϵ_{s,a}(π_θold) = sqrt(δ/π_θold(a|s)) from the second-order Taylor expansion of KL divergence (via the Fisher Information Matrix), so each token's update consumes an equal geometric distance (trust-region budget) rather than an equal ratio deviation. RIPO substitutes this dynamic clipping boundary into the GRPO-style group-relative, token-level policy-gradient objective (min-clip surrogate with group-normalized advantage, à la DAPO's token-mean loss), with default trust-region radius δ=0.05 and dual clipping bounds (0.5, 10). Experiments train Llama3.2-3B-Instruct, Qwen3-1.7B/4B/8B-Base for 300 steps with AdamW (lr=1e-6), 8 rollouts/question on DAPO-Math-17k (17,917 questions), batch size 128 with mini-batch 16, max response length 16,384 tokens, on the VeRL framework using 8×A100 GPUs; a PPO-objective variant (RIPO-Clip) is also tested on Qwen2.5-Instruct models (0.5B–14B) with GAE and a learned value model.

Key results:

• On Qwen3-8B-Base, RIPO improves average accuracy across seven math benchmarks from 28.5 (GRPO) to 38.5, a +35.1% relative gain over GRPO; on Qwen3-1.7B-Base, Llama3.2-3B-Instruct, and Qwen3-4B-Base the relative gains over GRPO are +37.2%, +34.4%, and +17.1% respectively, and up to 60% improvement over GRPO on AIME24 is cited in the abstract.
• On AIME24 specifically with Qwen3-8B-Base, RIPO reaches 43.8 vs GRPO's 31.7 and DCPO's 36.3.
• RIPO reaches GRPO's 200-step performance on AIME24 in only 40 steps (5x token-efficiency), per the training-dynamics analysis.
• On PPO objective with the GSM8K dataset (Avg@1), RIPO-Clip beats PPO-Clip/DAPO-Clip/DCPO-Clip across all model sizes tested (0.5B, 1.5B, 7B, 14B), e.g. 93.5 vs 91.7 (PPO-Clip) at 7B and 94.4 vs 93.2 at 14B.
• Pass@k analysis (k up to 128) on Qwen3-8B-Base shows RIPO reaching 60.0% Pass@128 on AIME-25 and 45.3% on HMMT-25, exceeding GRPO, DAPO, and DCPO at every k value reported.
• On coding tasks (Codeforces, CodeContest, TACO, APPS), RIPO averages 44.9 vs GRPO's 39.7 (+13.2%); on search tasks (TriviaQA, PopQA, HotpotQA, WikiMultiHopQA), RIPO averages 43.4 vs GRPO's 37.7 (+15.1%).
• Ablation on δ shows stable performance for symmetric δ∈[0.02,0.08] (Avg@8 ranging ~40.8–43.8 on AIME24), but highly asymmetric δ_low/δ_high settings cause performance to drop to ~27.5–28.8 with entropy explosion and training collapse.

Why it matters / caveats: The paper claims RIPO provides a theoretically grounded fix (rather than the "heuristic" fixes of DAPO, GSPO, GMPO, DCPO) that simultaneously resolves exploration collapse and yields a favorable bias–variance trade-off via induced statistical homoscedasticity, and that gains grow with model size, indicating better scaling. The main caveat stated by the authors themselves is hyperparameter sensitivity to asymmetry: when the lower and upper trust-region budgets (δ_low, δ_high) are set very differently, performance degrades sharply due to entropy explosion and training collapse, underscoring that both directions of policy update must be jointly constrained; no separate "Limitations" section was present in the extracted text.

Problem: Standard behavior-cloning (BC) finetuning of vision-language models (VLMs) into vision-language-action (VLA) policies progressively overwrites the VLM's pretrained visual and semantic representations, and even common co-training remedies leave the action and language prediction heads misaligned since they are supervised on separate observations.

Method: The paper proposes Anchor-Align, which adds two loss terms to the standard BC action loss (L1 regression or flow-matching L2 velocity loss): (1) Vision-Language Anchoring, a per-decoder-layer squared-Frobenius-norm distillation loss (Lanchor) between the trainable backbone's vision/text token hidden states and those of a frozen copy of the same pretrained VLM; and (2) Language-Action Alignment, which programmatically converts each continuous ground-truth action chunk into one of six discrete motion-direction labels (up/down/left/right/forward/backward, via average-chunking, stationarity filtering with threshold τ, and dominant-axis discretization) and supervises a cross-entropy loss (Lalign) on the last-layer hidden state of the last instruction token, projected through a learned matrix and the frozen LM head. The three losses are combined as Ltotal = Laction + λanchor·Lanchor + λalign·Lalign. The default architecture uses Prismatic-Qwen2.5-0.5B as backbone, LoRA (rank r=64) finetuning on all layers, a bridge-attention regression action head with 512 vision patches (concatenated DINOv2 + SigLIP features, 256 patches/image over two images); generality is also validated on StarVLA with a Qwen2.5-VL backbone and a GR00T FM-DiT flow-matching action head. Real-world evaluation uses a physical UFactory xArm7 robot.

Key results:

• Real robot: mean success rises from 28.3% to 54.2% with the VLA-Adapter/bridge-attention setup and from 36.7% to 60.0% with the StarVLA setup (e.g., spatial rearrangement 30%→60%, cluttered scenes 45%→70%).
• LIBERO-PRO position-swap (hardest axis): baselines (MolmoAct, OpenVLA-OFT) score 0% and VLA-Adapter scores 2.3%, while Anchor-Align VLA reaches 22.6%; overall mean success 90.3% on LIBERO-Plus and 71.9% on LIBERO-PRO vs. 85.1%/61.0% for VLA-Adapter.
• CALVIN ABC→D: Anchor-Align VLA attains the longest average rollout length (4.5 vs. 4.3 for VLA-Adapter) and raises five-instruction completion from 66.5% (OpenVLA-OFT) to 77.9%.
• Ablations show anchoring-only and alignment-only each improve over baseline (68.1/87.3 and 65.9/88.6 on PRO/Plus respectively) but combining them (71.9/90.3) exceeds either alone; corrupted-label "Shuffle" and "Scatter" controls collapse back toward the baseline (61.4/84.9 and 63.3/85.7), confirming the gain is not mere auxiliary-loss regularization.
• Analysis: standard BC loses 94% of GQA visual-reasoning accuracy within 10K finetuning steps while Anchor-Align retains 70%; language-action agreement on LIBERO-PRO rollouts rises from 16.8% (VLA-Adapter) to 78.4% (Anchor-Align), with the correlation between per-rollout alignment and success turning from -0.03 to +0.51.
• On the semantic-perturbation (pink-mug) test, standard BC picks the wrong (green) mug 90% of the time, whereas Anchor-Align picks the correct (pink) mug 100% of the time and places it on the plate in 40% of trials.
• Failure-mode analysis on real rollouts: Anchor-Align eliminates semantic errors (7→0), nearly eliminates incorrect-object approaches (10→1), reduces memorization errors (15→9), and nearly halves grasp failures (15→8), though grasp-and-drop errors slightly increase (12→13).

Why it matters / caveats: The paper argues effective action learning and preservation of pretrained VLM semantics are not fundamentally at odds, and that both proposed losses reuse supervision already present in demonstrations, requiring no extra data, annotation, or architectural change. A stated caveat is that on the hardest real-world semantic-perturbation test, the deterministic L1 regression head of VLA-Adapter could not capture multimodal action distributions, so that test was only reported with the flow-matching StarVLA setup; the authors also note grasp-and-drop errors slightly increased under Anchor-Align, attributed to more successful grasps creating more opportunities for drop errors.

Problem: Adaptive Top-p sparse attention in video Diffusion Transformers improves attention fidelity but creates uneven per-head workloads that become rank-level stragglers under multi-GPU Ulysses-style sequence-parallel inference, offsetting the speed gains sparsity is supposed to provide.

Method: FVAttn is a training-free sparse-attention runtime that combines a sparse-routing frontend (Top-p CDF thresholding with a Top-k safety floor, plus Hilbert-curve block reordering for similarity estimation on pooled Q/K) with two post-mask runtime mechanisms: Runtime Load Balancing (RLB), which migrates at most one local head per rank (~20% of local heads) via constrained one-send-one-receive P2P communication to minimize the new maximum rank load, and Slack-Aware Sparse Augmentation (SASA), which spends each non-critical rank's residual slack (budget Br = n1·ΔLr, with n1=0.8, trigger n2=0.07) on additional high-value key blocks from the routing's importance order without extending the critical path. The two mechanisms are switched on progressively based on the measured load-imbalance factor ρ (piecewise thresholds k1=1.05, k2=1.10), and an "Overlap/Opt." implementation hides scheduling/migration/augmentation costs via CPU–GPU overlap (search overlapped with V quantization) and computation–communication overlap. Experiments were run on Wan2.2-14B I2V, Wan2.2 Animate 14B, and Wan2.1-14B T2V under LightX2V 4-step distilled LoRA inference, on an 8×NVIDIA H20 GPU server (NVLink, CUDA 13.1) with 8-way Ulysses sequence parallelism.

Key results:

• On Wan2.2 I2V, RLB reduces the average load-imbalance factor ρ from 1.34 to 1.08 (further to 1.01 with SASA), and the full stack gives a 4.41× attention speedup over FlashAttention (attention latency 165.60 ms → 37.54 ms) with only ~0.7 ms (1.87%) visible runtime overhead.
• FVAttn achieves 2.02–2.11× DiT inference speedup on Wan2.2 I2V (e.g., 38.59s → 18.30s at Top-p=0.90) while improving VBench score (88.8% vs. 88.2% for SpargeAttention) and fidelity metrics (PSNR 23.473 vs. 21.477).
• On Wan2.2 Animate, adding RLB alone cuts DiT latency from 16.40s to 15.18s (7.4%, quality unchanged), and adding SASA on top improves PSNR by 0.458 dB (22.182→22.640) and reduces LPIPS by 13.9% (0.1239→0.1066) while DiT latency barely changes (15.18s→15.21s).
• RLB outperforms the db-SP baseline (lower imbalance: 1.08 vs. 1.22; lower attention latency: 41.32 ms vs. 44.17 ms), and on Wan2.1 T2V, FVAttn reaches a 2.32× DiT speedup (34.70s → 14.96s) with higher VBench (81.6% vs. 81.3% dense).

Why it matters / caveats: By repairing load imbalance from realized (not predicted) per-head workloads with bounded P2P migration and reinvesting idle slack into extra sparse-attention coverage, FVAttn improves the quality-efficiency Pareto frontier over existing training-free sparse-attention and load-balancing baselines for few-step video DiT inference. The authors note limitations: benefits shrink for short sequences or weakly sparse workloads (e.g., image generation); gains depend on the hardware's communication-to-computation ratio, being weaker on PCIe-connected devices with limited inter-GPU bandwidth (requiring recalibration of migration budget/thresholds); and the method is validated only under Ulysses-style sequence parallelism and few-step distilled inference, leaving Ring Attention, USP, other hardware topologies, and training-time sparse attention for future work.

Problem: Extending reinforcement learning with verifiable rewards (RLVR) to vision-language models is bottlenecked by the lack of training data that is simultaneously broad across visual domains, exactly verifiable, and reproducible.

Method: TRACE is a taxonomy-guided environment that factorizes task construction into a scene grammar (object vocabulary, relations, layout family) and an executable task program (candidate construction, operator, answer binding), with a shared semantic state driving the rendered image, prompt, typed answer, verifier state, and a replayable instance trace; task identity is formally defined as T = (S, P, Y, C) with an equivalence rule distinguishing bounded "query" variation, semantic/render-only generation parameters, and true new tasks. The environment comprises 1,000 tasks over 277 scene grammars across 11 visual domains, supporting integer, canonical numeric, string, and option-letter answer types with type-aware normalization/scoring. For training, Qwen2.5-VL-3B-Instruct and Qwen2.5-VL-7B-Instruct are each trained via GRPO (group relative policy optimization) on the same 64,000 TRACE instances (64 per task), with reward R = 0.95·R_a + 0.05·R_f (answer correctness plus a JSON-format term), 128 prompts per update × 8 responses each, 500 updates (one pass, 512,000 sampled responses), full-parameter BF16 training, learning rate 1e-6, temperature 1.0/top-p 1.0 rollouts, on 8 H100 80GB GPUs (12.2 hours for 3B, 13.9 hours for 7B).

Key results:

• Held-out TRACE validation accuracy rises from 24.45 to 41.05 (3B, +16.60 pts) and from 34.25 to 51.55 (7B, +17.30 pts).
• Across 24 external benchmarks, macro-average improves from 39.34±0.63 to 42.85±0.39 (+3.51 pts) at 3B and from 47.93±0.30 to 51.99±0.17 (+4.06 pts) at 7B, with gains on 21/24 benchmarks at 3B and 24/24 at 7B.
• Visual mathematics shows the largest category gain (+7.44 pts at 3B, +5.65 pts at 7B); WeMath shows the largest single-benchmark gain (+10.95 pts at 3B, +10.96 pts at 7B).
• The TRACE-trained 7B checkpoint beats other synthetic-data RLVR checkpoints under a common protocol: macro-average 3.94 points higher than Game-RL-7B, 2.64 higher than Sphinx-7B, and 3.18 higher than PC-GRPO-7B (Vero, with a larger 600K real-image mixture, is reported separately as a reference and scores higher).
• Training reward rises from 0.240 to 0.432 (3B) and 0.353 to 0.542 (7B) over 500 updates; mean response length grows from 198 to 308 tokens at 3B but only 211 to 237 tokens at 7B, while sampled-token entropy drops sharply at both scales (3B: 0.829→0.137; 7B: 0.361→0.088).

Why it matters / caveats: The results provide evidence that broad, structured procedural visual training can transfer beyond its own generated task distributions to diverse external benchmarks, supporting more reproducible multimodal-reasoning research with inspectable, exactly verifiable supervision. The paper notes limitations: the taxonomy and its 1,000 tasks are human-designed and do not exhaust visual reasoning, no cross-domain difficulty notion or mixture ablations were performed to attribute gains to specific domains/operations, results come from a single training run per scale (seed variation reflects only inference variability), comparisons to other RLVR checkpoints are descriptive rather than controlled (unmatched data/optimization/compute), and synthetic renderers may introduce regularities or ambiguities not present in natural images.

Problem: Latent (continuous-vector) chain-of-thought reasoners remain limited to imitation-based training because their continuous latent trajectories lack a tractable per-step likelihood and an adaptive stopping mechanism, preventing outcome-reward reinforcement learning from being applied to elicit latent test-time scaling the way it has been for explicit CoT.

Method: SLPO (Surrogate Latent Policy Optimization) adds two components to an autoregressive latent reasoner: (1) a stopping head g_θ trained via a correctness-supervised "stopping-gate cold start," which samples N=4 stochastic latent trajectories per problem (MC-dropout p=0.1, up to T_max=12, T_min=3) and supervises a first-stop probability distribution over answer-correct stopping lengths (Adafactor, lr 1e-4, 15 epochs); and (2) an empirical surrogate transition likelihood, where K=4 independent MC-dropout forward passes at each latent step form a diagonal Gaussian density over the realized hidden state, enabling a tractable log-likelihood for policy-gradient credit assignment (combined with answer-token likelihood and stopping-time likelihood into one rollout objective, optimized with RLOO or GRPO, G=8 rollouts, β=0, no KL penalty, Adafactor lr 1e-6, up to 40,000 steps, 4×RTX 5880 Ada GPUs via Accelerate). It is applied on top of frozen-initialization COCONUT and CODI checkpoints (GPT-2 124M and Llama-3.2-1B-Instruct, T_max=6 in original setups) and also transferred to a soft-token/vocabulary-weighted-embedding latent interface with Llama-3.2-1B/3B.

Key results:

• On Llama-3.2-1B, CODI+SLPO raises GSM8K Pass@16 from 67.48 to 70.28 and Pass@8 from 63.91 to 65.13, with Acc essentially flat (55.22→55.27).
• On GPT-2 (124M), COCONUT+SLPO improves GSM8K Acc from 34.12 to 35.63 and Pass@16 from 49.13 to 51.55.
• On GSM-Hard with Llama-3.2-1B, COCONUT+SLPO improves Acc from 4.55 to 5.77 and Pass@16 from 9.94 to 10.93.
• In soft-token transfer at 1B scale, SLPO reaches 46.70 Acc / 82.03 Pass@32 on GSM8K and 27.20 Acc / 71.60 Pass@32 on MATH500, outperforming GRPO and LEPO baselines; mean rollout length grows to 256.65 vs. GRPO's 238.50, while GRPO/LEPO rollouts stay near initialization or contract.
• At 3B scale on the hardest benchmarks, SLPO reaches 3.33 Pass@1 / 20.00 Pass@32 on AIME 2025 and 32.50 Pass@1 on AMC23, exceeding LEPO (0.96/16.67 AIME25; 27.03 AMC23).
• Harder problems receive longer learned latent trajectories (Pearson r=0.297 on GSM8K validation, r=0.262 on test between difficulty and mean latent length).
• RLOO and GRPO perform comparably under SLPO (e.g., COCONUT MultiArith Pass@16: RLOO 92.59 vs. GRPO 92.24), indicating the surrogate is not tied to one policy-optimization algorithm.

Why it matters / caveats: The approach is presented as bringing mature outcome-reward RL/test-time-scaling techniques from explicit CoT to latent reasoning without requiring vocabulary-level action probabilities, giving latent reasoners an adaptive, difficulty-aware compute budget rather than a fixed one. The paper's own conclusion notes this is validated only on relatively small backbones (GPT-2 124M, Llama-3.2-1B/3B) and grade-school/math reasoning benchmarks, with future work needed to extend SLPO to larger backbones, open-ended reasoning, and multimodal latent architectures; it also notes the surrogate is "not the exact density of MC-Dropout," just a scoring proxy.

Problem: Existing document-related benchmarks either reduce documents to read-only knowledge repositories or treat documents as passive data payloads passed between applications, leaving open whether autonomous LLM agents can reliably perform end-to-end, native-format document manipulation while preserving global document state consistency.

Method: DocOps is a deterministically verifiable evaluation framework built on a two-axis taxonomy: an operation axis (Content, Format, Structure) and a four-tier difficulty axis (L1 atomic, L2 composite, L3 single-document workflow, L4 cross-document workflow), yielding 210 tasks built through a four-stage pipeline (seed collection/filtering from 600 candidates down to 482 then to 210 tasks, task formalization into task_metadata.json, source-artifact synthesis, and iterative human review by a PhD-level reviewer). Each task is packaged as a self-contained Harbor bundle with a deterministic in-container verifier using three predicate types (structural predicates, linguistic anchors, and preservation predicates) that inspect the final artifact via native document libraries rather than LLM-as-judge or exact-match scoring. Experiments run through the Harbor framework across four execution harnesses (DocTools, Terminus-2, Codex, Claude Code, the latter two evaluated with/without official Anthropic document skills for xlsx/docx/pptx/pdf) on closed-source models (GPT-5.5, GPT-5.4, Claude Sonnet 4.6) and open-source models (DeepSeek-V4-Pro, Qwen3.6-27B, Qwen3.6-35B-A3B, Qwen3.5-122B-A10B/27B/35B-A3B/9B, Gemma4-31B, GLM-4.5-Air).

Key results:

• The best configuration overall (GPT-5.5 with Codex and skills) achieves only a 0.671 overall pass rate on the 210-task suite, still failing nearly one-third of tasks.
• Performance collapses with difficulty: GPT-5.5 drops from 0.725 pass rate on L1 to 0.237 on L4 averaged across harnesses.
• Excel workflows show the sharpest degradation, falling from the highest L1 pass rate to near-zero at L3/L4, with cross-format variation (FormatCV) rising from 0.120 at L1 to 0.436 at L3, while PDF workflows remain comparatively robust.
• Verifier fidelity checks show 95.31% agreement (122/128) with human judgments in a manual audit, and detection of 96.67% (174/180) of injected mutations in a stress test.
• Skill injection is inconsistent: e.g., under Claude Code, Qwen3.5-27B and Gemma4-31B improve by 7.1 and 6.7 percentage points with skills, but DeepSeek-V4-Pro and Qwen3.5-9B show negative point estimates, and under Codex most effects are smaller with intervals crossing zero.
• Three pervasive failure modes were identified — long-term state tracking failure, shallow/semantic verification gaps, and destructive editing of structural metadata — with semantic verification gaps dominating failed runs in the trajectory analysis.

Why it matters / caveats: The results expose that current frontier and open-source agents remain far from reliable at maintaining global, non-destructive document state during complex, long-horizon or cross-document tasks, motivating future agent designs focused on state-awareness and structural preservation rather than just task completion. The authors note limitations: DocOps covers only deterministic, offline editing (not live external services, collaborative editing, or interactive clarification); scaling the benchmark beyond its current 210 tasks is labor-intensive due to required manual review; and cross-harness token-cost comparisons should be interpreted cautiously since different agent runtimes expose usage statistics with varying fidelity.

Problem: Reconstruction-based faithfulness tests for natural-language activation explanations (verbalizer/reconstructor pairs) are structurally insensitive to individual false claims, so a high reconstruction score can be achieved without the explanation's specific claims actually being grounded in or true of the activation.

Method: The paper introduces two audit protocols — the grounded-vs-true cross (crossing whether a claim is reconstruction-sensitive to a minimal-pair "flip" edit against whether it is actually true) and the evaluator swap (testing grounding under an independent reconstructor not co-trained with the verbalizer) — plus a counterfactual flip-based measure Δr̃(c) using a floor-normalized centered cosine reconstruction score r̃. It then proposes RECAP (Readable Encodings via Co-trained Auxiliary Predictors): linear (and in one variant nonlinear/MLP) auxiliary heads attached to a chosen tap-layer hidden state of the target model, trained jointly with the language-modeling loss via Jmodel = min_{θ,ϕ} [L_LM(θ) + w·L_ϕ(h(θ), y)], where L_ϕ is class-balanced BCE for presence plus cross-entropy for identity of externally specified targets (e.g., sandbox slot values or self-supervised text functions). This is evaluated on a released Qwen-2.5-7B layer-20 verbalizer/reconstructor pair (n=1,517 audited claims), a synthetic template-grammar sandbox with exact ground truth (two domains), and continued pretraining of Pythia-160M with heads at K=8/64/512 targets, batch 64×1024, learning rate 1e-4, over up to 2,000 steps.

Key results:

• On the released Qwen-2.5-7B system, explanations reconstruct at r̃ = 0.84 while the flip audit finds grounding in only ~2% of LLM-salient specific claims (4.2%/2.1%/1.6% at τ = 0.02/0.05/0.10).
• In the exact-ground-truth sandbox, standard co-trained verbalizer/reconstructor pairs develop co-adapted private codes in 5/5 runs across two domains, with grounded-minus-true gaps of 0.30–0.80.
• RECAP achieves 100% designated-content decodability by fresh probes at only +0.001 nats cost in 5/5 sandbox runs, with 0/5 (full-designation) and 0/3 (partial-designation) runs showing any code signature.
• On Pythia-160M, RECAP reaches 0.95–1.00 fresh-probe AUC for designated content (K=8/K=64) versus a 0.77–0.80 control baseline, at a cost of +0.010 nats (within a 0.06-nat seed spread) for K=64; a fresh verbalizer states designated content truly at 0.44–0.46 versus near-zero for the control.
• An independent probe on RECAP-trained models ranks true vs. false verbalizer claims at AUC 0.965 (control: 0.823); under a report-space adversary that suppresses ~87% of the reconstruction score's lie penalty, the RECAP probe still detects lies at AUC 0.952 (0.86 recall) while the control probe collapses to chance (AUC 0.508).
• Sandbox auditor coverage of designated pre-tap content rises from 37% (standard model) to 100% (RECAP model).

Why it matters / caveats: The paper's central methodological claim is that a learned faithfulness test of a model's own explanations can be gamed, so supervising the target model itself to keep content probe-decodable is more reliable than auditing a trained model after the fact. The authors note key limitations: evidence comes mostly from a synthetic sandbox, one released NLA, and a single small model (Pythia-160M) at largely single seeds with frontier scale untested; RECAP must be co-trained (not retrofitted onto frozen models) and depends on well-chosen targets; decodability is not the same as verbalizability (free-form text conveys only part of decodable content); RECAP certifies what an activation stores but not what the model behaviorally uses (patching the tap barely moves behavior, ~0.003); and decodability is a "running cost" that erodes within a few hundred steps of head-free fine-tuning, requiring continuous or intermittent maintenance.

Problem: Constructing real-world synchronized multi-view RGB-thermal (RGB-T) aerial object detection datasets is costly and difficult due to limited viewpoint control, imperfect RGB-T alignment, and labor-intensive annotation.

Method: G-MAD transforms the commercial game Arma3 into a structured data-generation pipeline implemented in SQF (Arma3's native scripting language), decomposing generation into three stages: (1) scenario specification from user constraints (asset categories, object counts, weather, time, map, camera parameters, number of scenarios), (2) two-stage scenario/viewpoint sampling (s ~ P(S|constraints), v ~ P(V|s)) with two default camera motion modes ("air-to-air" and "air-to-land"), and (3) automatic annotation that queries engine-native 3D bounding-box geometry (via boundingBoxReal, modelToWorldVisual, and worldToScreen functions) and projects it to 2D to produce both HBB and OBB labels, with automatic filtering of occluded objects via line-of-sight checks. Using this framework the authors build the AMOD benchmark (12 classes, OBB-annotated, 1920x1440 resolution) and evaluate with an Oriented R-CNN detector using a Swin-S backbone via the MMRotate toolbox.

Key results:

• AMOD contains 73,920 image frames and 383.2k total bounding-box instances across 12 categories with multiple viewpoints and simultaneous RGB-T pairing.
• Multi-view training raises mean AP50:95 to 50.96 versus 44.57 for the best single-view model, a gain of +6.39.
• Cross-angular training/testing shows performance degradation under unseen viewing angles for single-view models (e.g., 0°-trained model drops from 51.16 AP50:95 at 0° test to 26.60 at 50° test).
• Pretraining on AMOD improves mean AP50 on DIOR-R (visible) from 63.14 (ImageNet init) to 69.83 (+6.69), and on HIT-UAV (thermal) from 74.57 to 77.08 (+2.51).
• An AMOD-trained detector, without fine-tuning, identifies plausible military targets in unseen real-world RGB satellite imagery from public news coverage of the Russia–Ukraine war.

Why it matters / caveats: G-MAD enables constraint-aware, multi-object, GUI-independent, engine-native-annotated synthetic data generation with multi-map and configurable-resolution support, addressing limitations of prior GTA V/Arma3-based pipelines (e.g., limited to ≤1 object per image, manual GUI control, image-differencing annotation). The paper states AMOD is primarily specialized for military targets because Arma3's built-in assets and terrains are well suited to military scenarios, though it notes Arma3 supports user-defined asset integration so G-MAD could also be used for non-military equipment; the framework also carries licensing restrictions (non-commercial academic/prototype use only, no redistribution of Bohemia Interactive IP).

Problem: Robotic grasping in cluttered, multi-object scenes needs to follow natural-language task instructions across multiple gripper embodiments, but existing approaches either use a VLM to predict grasps directly with limited spatial awareness or require expensive end-to-end training of the VLM with the grasping model, preventing scaling to multiple embodiments and cluttered scenes.

Method: SeededGrasp decouples semantic reasoning from geometric execution: an off-the-shelf VLM (Gemini 3.1 Flash, chosen after ablating GPT 5.4 and Qwen 3.5 Flash) zero-shot predicts a 2D seed point on a bird's-eye-view scene image given the language instruction, which is projected onto the scene point cloud and used to condition a lightweight flow-matching grasp-generation model. Point clouds (robot pr∈R1024×3, scene pc∈R2048×3) are Fourier-encoded with local normals/curvature and encoded via Graph Convolutional Networks (following GeoMatch) using 16 nearest neighbors, with a learnable per-gripper query vector qr∈R512; a Diffusion Transformer with cross-attention predicts the vector field uθ(t,gt,fr,fc) for the pose g=(T,R,θ), trained with a weighted combination of translation/rotation/joint L1 conditional flow-matching losses (λ=(0.4,0.04,0.8)), Beta(1.5,1.0)-sampled timesteps, and classifier-free guidance (w=1.1 at inference, Forward Euler integration with step size 0.2). Training used a new synthetic dataset of 2.56M grasps across 610 cluttered scenes, 334 objects, and 3 grippers (Franka Panda, Robotiq 3-Finger, Allegro), built from the MultiGripperGrasp dataset with heuristic collision filtering; the flow-matching model trained for 48 hours on two A100 GPUs.

Key results:

• Achieves 72% success in simulation and 78% in real-world grasping experiments (Delto DG-3F-B gripper, 15 unseen objects, 10 trials each).
• Outperforms DGN2.0 by 13% on single-embodiment (Allegro) grasping when conditioned on the same Graspness-module seed points (66.22% vs 53.15%), and VLM-predicted seed points outperform DGN2.0's trained seed module for both methods.
• Outperforms Geomatch on multi-embodiment cluttered-scene grasping by roughly 35% (e.g., 71.38%/72.16%/72.07% vs 25.35%/35.71%/37.97% for Franka/Robotiq/Allegro).
• Outperforms ShapeGrasp and GraspMAS on language-conditioned grasping: 89.6%/80.6% object-and-part recognition on easy/difficult prompts (vs. 57.5%/51.6% and 42.5%/29.0%) and 58.2% overall grasp success (vs. 31.1% and 24.5%).
• Ablations: removing either the gripper point cloud or the learnable query vector reduces success rates (e.g., Robotiq drops from 72.16% to 69.07% or 67.53%); Gemini 3.1 Flash (71.87% avg) outperforms Qwen 3.5 Flash (54.42%) and GPT 5.4 (42.61%); dataset-size ablation shows performance saturating around 71.5% with diminishing returns from more scenes.

Why it matters / caveats: The seed-point interface lets a pretrained, unmodified VLM guide a compact flow-matching model without costly end-to-end VLM training or a language-annotated dataset, enabling multi-embodiment grasping in cluttered scenes at lower training cost. The paper's stated limitations: the model predicts grasp poses without arm-kinematics awareness so predicted poses may be unreachable; it relies on single-image (BEV) VLM conditioning rather than multi-view input, which limits robustness under occlusion; per-gripper learned query vectors limit generalization to unseen hardware; and the training data's over-representation of power grasps (from MGG) limits effectiveness on flat objects sitting flush against a surface.

Problem: Existing feed-forward 3D Gaussian Splatting methods regress Gaussians densely at input pixels, so the number and placement of primitives depends on image resolution and viewpoint count rather than scene complexity, producing redundant, storage-inefficient Gaussian sets.

Method: ATSplat first tokenizes multi-view images with a frozen DINOv2-B backbone plus Plücker raymap embeddings and a 12-layer multi-view self-attention encoder, then unprojects predicted patch-level depths into sparse 3D anchor tokens (with local context aggregated via a PointNet-style kNN operator) to form a scene scaffold. A 4-block image-to-3D decoder refines these anchors via cross-attention to finer per-view features, and an Adaptive Token Expansion (ATE) module in each block (except the first) predicts a per-anchor uncertainty score with a lightweight MLP, supervised by 2D D-SSIM error maps of intermediate rendered Gaussians (loss L_unc, with stop-gradient), and expands the top ρ_l fraction of high-uncertainty anchors (ρ_l = 0.5, 0.5, 0.25; expansion ratio 2) into child tokens via a learned linear projection. Each final anchor is decoded by a 2-layer MLP Gaussian head into K=16 local Gaussians with 3D offsets from the anchor. Training uses a combined objective (Lrender = L_MSE + 0.5·L_perceptual, plus intermediate rendering losses weighted 0.5 and uncertainty losses weighted 0.1 across blocks); the base model is trained on RealEstate10K (2 views) on 4 RTX 4090 GPUs for ~2 days, further trained on DL3DV (6 views) on 4 H200 GPUs for 2 days, and fine-tuned for high-resolution (10 views) on 8 H200 GPUs for under 2 days.

Key results:

• On RealEstate10K (256×256, 2 views), ATSplat achieves PSNR 28.46/SSIM 0.894/LPIPS 0.118 using only 23K Gaussians versus 131K for baselines like DepthSplat/iLRM — a 5.7× reduction in Gaussian count.
• On DL3DV (256×448, 6 views), ATSplat reaches PSNR 27.28/SSIM 0.868/LPIPS 0.138 with 120K Gaussians, outperforming DepthSplat (PSNR 24.19, 688K Gaussians) and iLRM (PSNR 25.60, 172K Gaussians).
• On DL3DV at 512×960 (100-frame baselines), ATSplat obtains PSNR 24.85 with 311K Gaussians in 0.677s, versus iLRM's PSNR 24.35 with 1,474K Gaussians (0.700s) and DepthSplat's PSNR 21.33 with 5,898K Gaussians (0.758s); at this resolution rendering reaches 1136 FPS.
• Ablations show the anchor-plus-offset design outperforms pixel-aligned, learnable-token, and direct-xyz variants (e.g., 28.46 vs. 27.35 PSNR for pixel-aligned), and uncertainty-guided ATE expansion outperforms random selection, farthest point sampling, and a straight-through-estimator variant, and beats "no expansion" (28.46 vs. 27.02 PSNR).

Why it matters / caveats: The results support the paper's claim that feed-forward 3DGS quality depends more on how representational capacity is allocated than on how densely Gaussians are sampled, enabling compact, real-time-renderable reconstructions from a single forward pass on a single commercial GPU. The authors note limitations: ATSplat expands tokens adaptively but does not prune redundant ones during decoding (unlike per-scene 3DGS densification/pruning), and further architectural work is needed to scale to larger scenes, more input views, higher resolutions, and unposed image settings.