acceptodds
Under review as a conference paper at ICLR 2027

VLA Models Inherit the Meaning of Words, Not the Use of Their Reasoning

Abstract

Vision-language-action (VLA) models are built on language models so that robots can use their reasoning. Acting on a reasoned instruction requires deriving the goal, setting it as the goal of the action and executing the movement; chain-of-thought policies, hierarchies and language-preserving training seek to connect these steps, but task success alone cannot show which one fails. We identify the variable through which language sets the goal: a low-dimensional goal code, inherited from the parent language model, that the action reads. In OpenVLA and π₀.₅, writing the code redirects the robot and deleting it removes the goal, while a matched random subspace does neither, so the code tells whether a computation reaches the action. By this test, VLA models can reason but cannot act on it. Text-restored OpenVLA policies answer a rule correctly when asked in text, yet told the rule as their instruction they leave the bowl in place (0 and 1 of 30 episodes): the robot's input does not engage the computation. That text answer, written into the goal code of the same policy while it hears a plain instruction, drives it to the rule's destination in 24 and 26 of 30. Across ten models, word meaning reaches the code but a destination selected by an in-context rule does not; a stated goal moves the action as far as training made the action depend on it; and conclusions delivered to the code drive both families (22 to 28 of 30 episodes). VLA models inherit the meaning of words, not the use of their reasoning.

Primary area:
interpretability and explainable AI
Keywords:
mechanistic interpretability, vision-language-action models, activation patching, goal representation, embodied chain of thought, causal intervention, language grounding, representation steering

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_qUieOpenReview ↗
Rating
3
Confidence
2
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

This paper investigates whether language reasoning governs goal selection within VLA policies. The study identifies low-dimensional goal code in the OpenVLA and π0.5 models and tests their behavioral impact through read, write, and delete operations. Results from experiments in the LIBERO benchmark indicate that merely restoring text-based reasoning is insufficient to prompt the model to re-execute rule-based actions; however, explicitly injecting the decoded goal significantly improves task success rates when paired with clear instructions.

Critical strengths
  1. Causal evidence beyond mere detection. Redirecting the target code resulted in the redirection of 18/20 OpenVLA episodes and 10/10 π0.5 episodes, whereas corresponding control experiments using random subspaces yielded no such redirections. Supplementary ablation experiments further confirm that these representations influence target selection.
  2. Decoupling of informational capabilities. While the text-recovery strategy enables the model to correctly answer rules, it rarely leads to direct execution; injecting the decoded answers significantly boosts success rates. Experiments with controlled instruction visibility further elucidate how the training process establishes a dependency between behavior and the generation of target text.
Critical weaknesses
  1. These conclusions extend beyond the scope of the experiments. The core reasoning experiments cover two VLA model families, focusing primarily on rule-based constraints and negation logic within the LIBERO kitchen environment (across three target scenarios). The comparative analysis of ten models includes base models and their respective checkpoints; meanwhile, the broader transfer experiments primarily assess code-manipulation capabilities rather than reasoning abilities. These results only support in-depth investigation into specific mechanisms; they are insufficient to warrant the sweeping conclusion that "VLAs lack reasoning capabilities." The paper’s title and conclusions should be qualified accordingly.
  2. Causal correlation does not establish the validity of cross-format diagnostics. Since goal prototypes are derived by fitting them to literal instructions, the possibility remains that goal-related information is encoded in other way, even if rule-decoding performance is no better than random chance. Furthermore, while injecting the correct code under rule-based instructions can achieve 93%–95% accuracy in target outputs, OpenVLA failed in all 30 attempts. Consequently, the success observed after switching to literal instructions does not definitively reveal the mechanism behind the initial failure. The analysis should distinguish between failures in reasoning, mismatches in representation, and failures in subsequent execution.
Questions for authors
  1. In a decoder trained on rule-based formats, can the model recover the expected target output for previously unseen bindings when "literal-prototype decoding" fails?

  2. Even when rule-based instructions are followed and the correct code has been injected, why do execution failures persist? Furthermore, which stages of execution failure can the diagnostic method proposed in this paper reliably distinguish?

1 comment

We thank Reviewer qUie for the positive evaluation (3: Weak acceptance, Presentation: 3, Informativeness: 3) and helpful suggestions. All points are addressed in the revised PDF:

1. Qualifying the title and claims to match experimental scope (W1 — Title, Abstract, §1, §9): We agree completely. Our results do not claim that VLAs lack reasoning capability—indeed, text-restored OpenVLA answers unseen rules accurately (0.90–1.00) and goal-code supervision executes unseen marker-first rules directly (23–28/30, new §8). Rather, standard VLA training inherits lexical word meaning into the goal code without automatically routing in-context reasoning there. We kept the qualified title (VLA Models Inherit the Meaning of Words, Not the Use of Their Reasoning) and explicitly scoped Abstract, §1, and §9 to the tested OpenVLA and π0.5\pi_{0.5} lineages in LIBERO simulation.

2. Rule-format decoder on unseen bindings (W2a, Q1 — §4, App. F, new Table 21): Question: Can a decoder fitted directly on rule formats recover unseen bindings when literal-prototype decoding fails?

  • No on native unasked robot inputs, and Yes on plain-text rule questions with the exact same decoder.
  • We bypassed literal instructions, fitted destination prototypes directly on held-out rule sentences (marker sets 2–3), selected the best layer across the entire backbone via leave-one-group-out CV, and tested on unseen marker bindings (sets 0–1, chance 0.33).
  • On unasked robot rule inputs, decoding remains near chance across all tested policies (0.39–0.44 in OpenVLA, silent, Prismatic, and π0.5\pi_{0.5}). Yet the identical builder recovers 0.86–1.00 (31–36/36, layer 21) on plain-text rule questions (S1) and 0.92 (11/12, layer 6) on asked negations. Thus chance decoding on robot rules reflects genuine absence of derived target content, not prototype-format mismatch.

3. Raw-rule execution failure, carrier-free training, & 3-stage failure taxonomy (W2b, Q2 — §7, §8, §9): Why unmodified OpenVLA stalls (0/30) on raw rules even with oracle codes:

  • This stall is specific to unmodified OpenVLA's prompt-length OOD shift (fine-tuned only on 6–10 token commands), not universal: in-place oracle writes on raw sentences already lift π0.5\pi_{0.5} rules (0->14/20) and OpenVLA negations (16->22/30, App. H).
  • Direct carrier-free proof (new §8, Table 5): Training text-restored OpenVLA on raw rule prompts with the action loss alone removes the length stall yet stays at chance (8, 11/30). Adding goal-code supervision Lcode\mathcal{L}_{\text{code}} at layers 8–16 raises unseen-marker readout to 0.99–1.00 and reaches 23–28/30 closed-loop success directly on raw rule prompts with NO literal carrier (17–27/30 when self-distilled from the policy's own text answer).

Which failure stages our diagnostic reliably separates (§7 & §9): Combining (i) literal goal-code readout, (ii) format-matched full-depth probing (Table 21), and (iii) closed-loop code writing cleanly separates:

  1. Reasoning / derivation failure: Neither GℓG_\ell nor a format-matched probe at any layer recovers the target above chance (unasked robot rules; rule-first order before deep retrieval).
  2. Representational / routing mismatch: A format probe recovers the answer elsewhere (e.g., S1 text rules at L21 or asked negations at L6), yet it misses GℓG_\ell at action commitment; writing it into GℓG_\ell rescues execution (24–26/30, Table 2).
  3. Downstream execution failure: GℓG_\ell encodes the right destination (0.87–1.00 on descriptions; 0.93–0.95 on code-injected raw OpenVLA rules), yet rollout execution fails downstream.
Reviewer_bSi5OpenReview ↗
Rating
1
Confidence
3
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

This paper investigates whether reasoning performed by the language backbone of a vision-language-action model is actually used to guide its actions. The authors identify a low-dimensional “goal code” in the model’s hidden states and use activation reading, writing, and deletion interventions to study its relationship with robot behavior. Their experiments suggest that goal semantics are represented in the goal code, whereas destinations selected through in-context rules often fail to reach it. Furthermore, injecting a model-generated conclusion into the goal code enables the policy to execute the corresponding action.

Critical strengths
  1. An interesting research question. Understanding whether a VLA policy actually uses its reasoning results, rather than merely producing plausible textual explanations, is an important problem, Separating goal selection from downstream execution could help distinguish different failure modes in embodied policies, provided that the proposed diagnostic is sufficiently validated.

  2. Causal interventions on internal representations. The authors go beyond correlational probing by intervening on the proposed goal code and evaluating the resulting robot behavior. The writing and deletion experiments provide useful evidence that the identified representation is behaviorally relevant.

Critical weaknesses
  1. The role of the goal code is unclear. The paper does not sufficiently establish that the proposed goal code captures the results of the model's reasoning, rather than merely representing action-relevant information . I didn't find any clear explannation about "h(x,i)" except "hℓ,p(x,i) is theresidual stream...", The role of the proposed goal code and its relationship to reasoning are not explained with sufficient clarity, leaving important assumptions implicit. maybe author should give us more analysis why this vector could captures the results of the model's reasoning.
  2. The experimental scope is too narrow. The task setting is highly constrained. Most experiments use a single simulated kitchen environment with a limited set of objects, destinations, and rule-based instructions. Evaluating multiple models or checkpoints within similar task settings does not establish that the findings generalize across environments and task types.
  3. writing and presentation undermine the paper's arguments. what is "reasoning", what is "the meaning of words"?The paper does not clearly connect its key concepts, experimental design, and conclusions, making it difficult to understand how the evidence supports the main claims,
Questions for authors
  1. Why should hℓ,p(x,i)h_{\ell,p}(x,i) be interpreted as a representation of reasoning results rather than merely action-relevant information? Can the authors provide further justification?

2.Do the findings generalize beyond the narrow simulated kitchen setting to other environments, tasks, and forms of embodied reasoning?

  1. How do the authors define reasoning and the meaning of words, and how do the experiments operationalize these concepts to support the paper's central claim?
1 comment

We thank Reviewer bSi5 for recognizing the importance of the research question and the value of our causal interventions. We appreciate your candor where compressed notation and implicit definitions hindered readability; in the revised PDF, we clarified all three core issues:

1. Clear definitions of "word meaning" vs. "reasoning" (W3, Q3 — §1): We added explicit operational definitions in §1:

  • Word meaning (lexical semantics): Resolving a target from fixed, context-independent word associations stored in pretrained weights—tested via literal nouns, paraphrases, and noun-free descriptions (e.g., "the appliance used for cooking" →\to stove).
  • In-context reasoning: Deriving a target from context-dependent bindings or logical operators stated within the prompt, where all candidate destinations appear symmetrically so lexical associations alone cannot identify the target—tested via unseen-marker rules ("red means plate, blue means stove, green means cabinet; the marker is blue"), two-clause negations in both word orders, and explicit chain-of-thought subgoals (§6).

This operationalization directly grounds our central claim: across the tested VLA policies, word meaning reaches the goal code reliably (even without naming the destination), whereas in-context rules remain near chance—even under a rule-format decoder searching all layers (new Table 21)—unless the conclusion is explicitly written into the code (Table 2) or directly supervised onto it during training (new §8, Table 5).

2. Why hℓ,p(x,i)h_{\ell,p}(x,i) and the goal code gig_i capture abstract goal identity rather than action features (W1, Q1 — §3 Eq. 1, App. A): In §3, hℓ,p(x,i)h_{\ell,p}(x,i) is simply the Transformer backbone residual state at layer ℓ\ell and token pp for camera frame xx and instruction ii—the sole pathway through which language can steer the action head. Because hℓ,p(x,i)h_{\ell,p}(x,i) mixes visual features, motor state, and language, we formalize:

hℓ,p(x,i)=μℓ,p+vℓ,p(x)+gi(ℓ,p)+ξℓ,p(x,i).h_{\ell,p}(x,i) = \mu_{\ell,p} + v_{\ell,p}(x) + g_i(\ell,p) + \xi_{\ell,p}(x,i).

Comparing instructions on the exact same camera frames cancels the visual/pose state μ+v(x)\mu+v(x), and averaging across frames removes frame-specific visual/motor interactions ξ(x,i)\xi(x,i), isolating the abstract goal vector gig_i. Three controls confirm gig_i is semantic goal identity rather than low-level motor features:

  1. Exists without images or actions: Pure-text Llama-2-7B shares the same additive object + destination structure, and injecting its pure-text difference directly into OpenVLA redirects the robot (17/20 episodes vs. 0/20 random).
  2. Invariant to motor trajectories (Table 11b): Physically moving the plate requires a completely different arm trajectory, yet injecting the exact same fixed vector gplate−gcabinetg_{\text{plate}}-g_{\text{cabinet}} drives the robot to the plate's new location.
  3. Separate semantic slots (Table 10): Writing the wine-bottle code into the object slot makes the robot grasp the bottle, whereas writing it into the destination slot still grasps the bowl.

3. Scope and generality (W2, Q2 — Abstract, §1, §9): Within simulation, we tested generality across two distinct VLA lineages (autoregressive OpenVLA/Llama-2 + public ECoT vs. flow-matching π0.5\pi_{0.5}/PaliGemma, which share the same goal-code geometry), unseen scenes and compositions (an unseen LIBERO-90 kitchen, a 2×42\times 4 object–destination grid, LIBERO-object, and multi-stage LIBERO-10), and four forms of linguistic inference. At the same time, we agree that physical real-robot and broader embodied domains remain untested, and we explicitly scoped our claims in the Abstract, §1, and §9 to the tested open architectures and LIBERO simulation.

Reviewer_v5f1OpenReview ↗
Rating
2
Confidence
3
Informativeness
3
Presentation
2
Soundness
2
Read review
Paper summary

This paper investigates which linguistic computations influence a VLA policy’s actions. It identifies a low-dimensional, frame-matched goal code in OpenVLA and pi0.5, and tests its role through readouts, activation writes, deletions, and matched random controls. Word meanings and descriptions reach this code, whereas the tested in-context rule selections generally do not. Two text-restored OpenVLA policies trained on literal robot instructions can answer rules in separate text questions, yet achieve only 0/30 and 1/30 successful rule-instruction episodes; writing each policy’s decoded answer into a literal instruction carrier yields 24/30 and 26/30 successes (Table 2). Matched policies also show that a stated target controls behavior only to the extent that training made it necessary. The main contribution is a mechanistic account of the separation between text competence, goal selection, and execution in the tested policy families.

Critical strengths
  1. Causal evidence beyond decodability. The goal-code difference redirects 18/20 OpenVLA episodes and 10/10 pi0.5 episodes, versus 0/20 and 0/10 for the matched random-subspace controls; deletion and object-identity controls further support a behaviorally relevant goal representation (Table 1; Appendix D). This makes the representation useful for investigating language-to-action mechanisms, beyond showing that a probe can recover a task label.
  2. Controlled separation of competence and use. The same-policy answer-to-action rescue in Table 2 and the matched talking/half/blind policies in Table 3 are especially informative. Forced targets redirect 0/20, about 10–11/20, and 19–20/20 episodes as access to the instruction is reduced during training. These comparisons provide useful evidence that possessing text competence or emitting a target does not ensure that control depends on it.
Critical weaknesses

W1. Semantic interpretation needs stronger justification. Matching images does not remove instruction-dependent visual grounding. The interventions demonstrate behavioral relevance, but do not establish that the edited directions specifically encode the intended target semantics. A clearer theoretical account and mathematical justification of this correspondence would strengthen the mechanistic claims. W2. Low dimensionality partly follows from construction. Ten centered prototypes span at most nine dimensions. Appendix A nevertheless includes an arbitrary tenth QR direction in some operations. Please verify the relevant effects with a rank-nine basis; low dimensionality alone does not establish a compact semantic mechanism. W3. Correct target decoding does not ensure execution. Appendix H reports 0.93–0.95 correct-target decoding but 0/30 successful episodes under the original rule instruction. Successful rescue instead uses a literal carrier. This context dependence limits how fully the goal code localizes the failure and should be explicit in the main text and limitations. W4. Physical-world validity is untested. Core reasoning tests concentrate on one bowl, three destinations, and two model lineages in LIBERO simulation. No real-robot experiments are reported. Physical validation would help establish whether these effects persist beyond simulation; until then, the conclusions should be scoped accordingly.

Questions for authors

Q1 (W1–W2). How do the controls distinguish target semantics from instruction-conditioned visual processing? Do span interventions remain effective after removing the arbitrary tenth QR direction? A held-out rule-format readout would also help test representational-format dependence. Q2 (W3). Which necessity and redirection conclusions hold across matched carriers, tasks, token sites, and layer bands? Please state correct decoding without execution and the absence of real-robot validation as explicit limitations. Q3 (W4). Please justify 10 versus 20 episodes, identify reused initial states or evaluations, and report paired results by training seed with repeat uncertainty. How does the 9/20-to-19/20 NumPy sensitivity affect the conclusion? Please identify anonymous code, checkpoints, configurations, commands, and raw logs.

1 comment
AuthorsOpenReview ↗

Response to Reviewer v5f1

We thank Reviewer v5f1 for the rigorous, constructive review. Below we directly answer Q1–Q3 (with full details and raw logs in the revised PDF and vlalens_supplementary_anon.zip):

Q1 (W1–W2): Visual grounding, rank-9 verification, and held-out rule-format readout

  • Target semantics vs. visual grounding (§3 Eq. 1, App. A): We formalize hℓ,p(x,i)=μℓ,p+vℓ,p(x)+gi(ℓ,p)+ξℓ,p(x,i)h_{\ell,p}(x,i)=\mu_{\ell,p}+v_{\ell,p}(x)+g_i(\ell,p)+\xi_{\ell,p}(x,i). Matching frame xx cancels visual background μ+v(x)\mu+v(x) and averaging over frames cancels frame-specific visual grounding ξ(x,i)\xi(x,i), isolating abstract semantics gig_i. Three controls confirm this: (i) image-free Llama-2 shares the same additive structure and its pure-text difference redirects OpenVLA (17/20 vs. 0/20 random, App. D); (ii) injecting the fixed plate code tracks a physically shifted plate (Table 11b), showing spatial grounding occurs downstream; and (iii) the LIBERO-goal vector transfers zero-shot to an unseen LIBERO-90 kitchen (13/20, Table 1).
  • Exact rank-9 verification (§3, Table 1, App. A, Table 9): Centered prototypes have exact rank 9 (σ10/σ9≤8.4×10−7\sigma_{10}/\sigma_9 \le 8.4\times 10^{-7}; top-3 directions carry 55–77% of variance). The tenth QR vector q10q_{10} arose from float32 rounding along Llama-2's massive-activation dim 1512. Removing q10q_{10} via the exact rank-9 SVD basis (gtop9) vs. rank-9 random (rproj9) on OpenVLA L8–16 preserves both write redirection (15/20 vs. 0/20, p=1.2×10−6p=1.2\times 10^{-6}) and deletion necessity (0/10 vs. 8/10, p=7.1×10−4p=7.1\times 10^{-4}), while leaving low-level bowl reaching intact (7/10), matching last7 and rank-3 deletions.
  • Held-out rule-format readout (§4, App. F, new Table 21): Fitting prototypes directly on held-out rule sentences (sets 2–3, best layer across all layers via LOGO CV) still stays near chance on unasked robot rules (0.39–0.44), whereas the exact same builder decodes 0.86–1.00 (31–36/36, L21) on text rule QA (S1) and 0.92 (11/12, L6) on asked negations, ruling out format mismatch.

Q2 (W3): Carriers, layer bands, & explicit limitations

  • Raw prompts vs. carrier (§7, new §8 Table 5, App. H): In-place writes on raw prompts already lift π0.5\pi_{0.5} rules (0->14/20) and OpenVLA negations (16->22/30). Unmodified OpenVLA stalls on raw 30-token rules (0/30) due to prompt-length OOD shift; new §8 (Table 5) solves this via goal-code supervision Lcode\mathcal{L}_{\text{code}} at L8–16, reaching 23–28/30 (17–27/30 self-distilled from own text answers) directly on raw unseen-marker rules with NO carrier (vs. 8, 11/30 without Lcode\mathcal{L}_{\text{code}}).
  • Sites & bands (Tables 9, 11, 15): Control commits at L0–16 in OpenVLA and L0–4 in π0.5\pi_{0.5}, and governs actions only where training made language necessary (LIBERO-goal, not single-target LIBERO-object).
  • Explicit limitations (§7 & §9): Both limitations—accurate code decoding without guaranteed execution and the absence of real-robot validation—are now explicitly stated in §7 and §9.

Q3 (W4): Sample sizes, paired seeds, NumPy sensitivity, & anonymous archive

  • Budgets & reused states (App. J): n=30n=30 (3 destinations x 10 states) for 3-way tasks, n=20n=20 for single-pair swaps, and n=10n=10/task for multi-band sweeps. Fitting demos are disjoint; edits and controls share identical initial states in one job to cancel scene variance pairwise.
  • Paired seeds & repeats: All trained recipes report unpooled paired seeds (0, 1) side by side (Tables 2, 3, 5, 16–20); 47/47 re-run cells reproduce within 0–3 episodes (p≥0.34p\ge 0.34).
  • NumPy 9/20 vs. 19/20: Forward reads are bit-identical; the shift affects only one App. G withheld-prompt cell of half, leaving Table 3 unaffected and preserving talking < half <= blind under both versions.
  • Anonymous archive: Uploaded in vlalens_supplementary_anon.zip (anonymized vlalens code, configs, CLI commands, fitted glens files, and 237 raw summary.json logs including rank9_rebuttal_summary.json).

Comments on the paper

1 comment
AuthorsOpenReview ↗

Official Comment to Area Chair and All Reviewers

We thank the Area Chair and Reviewers qUie, v5f1, and bSi5 for their thoughtful, constructive reviews. All three highlighted our causal closed-loop evidence beyond probing and our controlled decoupling of text competence from behavioral use.

We have uploaded a revised 10-page double-blind PDF (preserving all original figures and Table 1–4 numbering) along with an anonymized supplementary archive (vlalens_supplementary_anon.zip: vlalens code, scripts, fitted glens dictionaries, CLI commands, and raw summary.json logs). Summary of key revisions:

  1. Carrier-free rule execution via goal-code supervision (new §8, Table 5, App. I): Supervising the centred goal code at layers 8–16 where the action reads its goal trains an in-context binding directly on raw rule prompts without any literal carrier, achieving 23–28/30 success on unseen marker words (17–27/30 when self-distilled from the policy's own text answer vs. 8, 11/30 without the loss). Rule-first order stays at chance because backward retrieval finishes deeper than action commitment.
  2. Held-out rule- and negation-format decoders (§4, App. F, new Table 21): Fitting destination prototypes directly on held-out rule sentences (searching all layers via LOGO CV) still yields near-chance decoding on unasked robot rules (0.39–0.44), whereas the exact same builder recovers 0.86–1.00 on text rule questions (S1) and 0.92 on asked negations—ruling out prototype-format mismatch.
  3. Exact rank-9 basis verification (§3, Table 1, App. A, Table 9): Removing the float32-rounding tenth QR vector (which partially aligned with Llama-2's massive-activation dim 1512) via the exact rank-9 SVD basis preserves both write redirection (15/20 vs. 0/20 random rank-9) and deletion necessity (0/10 vs. 8/10 completion), while keeping low-level bowl reaching intact (7/10).
  4. Clearer definitions & semantics-vs.-grounding theory (§1, §3 Eq. 1, App. A): Added explicit operational definitions of word meaning vs. in-context reasoning (§1), formalized hℓ,p(x,i)=μ+v(x)+gi+ξ(x,i)h_{\ell,p}(x,i)=\mu+v(x)+g_i+\xi(x,i) (§3), and consolidated controls separating abstract semantics gig_i from visual grounding (image-free Llama-2 transplant, physical plate shifts, unseen LIBERO-90 transfer).
  5. Scoped claims, explicit limitations, & reproducibility (§7, §9, App. J): Qualified claims across Abstract, §1, and §9 to the tested OpenVLA/π0.5\pi_{0.5} lineages in LIBERO simulation, stated our 3-stage failure taxonomy and explicit limitations (accurate decoding without execution; no real-robot validation), and documented paired seeds, NumPy controls, and anonymous code/logs.
Reviewer ConcernWhere Addressed
Semantics vs. grounding & hℓ,ph_{\ell,p} theory (v5f1 W1/Q1, bSi5 W1/Q1)§3 (Eq. 1), App. A, Tables 6, 10, 11b
Exact rank-9 basis & spectrum (v5f1 W2/Q1)§3, Table 1, App. A, Table 9
Rule-/negation-format decoders (v5f1 Q1, qUie W2/Q1)§4, App. F, new Table 21
Raw-prompt stall, carrier-free training & 3 stages (v5f1 W3/Q2, qUie W2/Q2)§7, new §8 & Table 5, §9, App. H–I
Definitions, scope, limitations, seeds, NumPy, code (qUie W1, v5f1 W4/Q3, bSi5 W2–3)Abstract, §1, §9, App. J, vlalens_supplementary_anon.zip

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.