Qwen Register-Token Latent Compiler
The one idea you need
The model writes a step-by-step calculation into a fixed row of blank slots — a starting number, then one operation and one number per step. A hidden calculator reads only those slots, never the original question, and runs them exactly.
The question
Can a small model quietly encode a runnable step-by-step calculation into a fixed set of hidden slots, so a separate calculator can then execute it correctly?
What we found
Only for short chains. Up to twelve steps it builds the correct hidden program about nine times in ten, while stripped-down versions trained on the final answer alone never find the interface and stay at chance. But at twenty-four steps whole-program accuracy crashes to 22 percent — each slot is still about 90 to 97 percent right, yet many near-misses multiply into failure.
Why it matters
When you route reasoning through predicted or latent steps, per-step accuracy flatters you — measure whole-chain correctness and agreement across rephrasings. For reliable long chains, train directly against full-trajectory errors, not just the final answer.
On this page
Results at a glance 6
How to read
The horizontal axis is chain length in steps (4, 8, 12, 24); the vertical axis is whole-program execution accuracy, higher is better. One line is standard prompt wording, the other reworded prompts of the same task.
Takeaway → Both lines sit near 90 to 95 percent through twelve steps, then plunge at twenty-four — standard to 22 percent, reworded to 3 percent: short chains work, long ones break.
Data table
| chain length (ops) | standard prompts | paraphrased prompts |
|---|---|---|
| 4 | 88.3% | 90.6% |
| 8 | 94.5% | 91.4% |
| 12 | 94.5% | 89.1% |
| 24 | 21.9% | 3.1% |
Numbers from experiments/qwen_register_token_latent_compiler/analysis/final_metrics.csv
Technical framing
Register-token compiler accuracy vs chain length — The trace-supervised register interface works for chains up to length 12 (~89-95%) but collapses at held-out length 24.
How to read
Grouped bars across three twenty-four-step splits (standard, reworded, paired). Each split has three bars: the step-by-step-trained compiler versus a direct-answer control and an answer-only control. Taller is better; guessing scores about 1 percent.
Takeaway → The trained run tops every split (22, 3, 13 percent) while both controls sit near chance (0 to 3 percent): step-by-step training, not final-answer training, built the interface.
Data table
| evaluation split | register trace (main) | direct answer head | register answer-only |
|---|---|---|---|
| Standard L24 | 21.9% | 3.1% | 1.6% |
| Paraphrase L24 | 3.1% | 0% | 0% |
| Paired L24 | 12.5% | 1.6% | 0% |
Numbers from experiments/qwen_register_token_latent_compiler/analysis/all_final_metrics.csv
Technical framing
Length-24 accuracy: register trace vs control heads — Even where length-24 is hard, the trace-supervised register run beats both controls, which stay at chance (1/97 is about 1%).
How to read
Bars for five measures at twenty-four steps — starting value, operation, argument, whole-program exact, and executed answer. Height is accuracy, higher is better. Two colors: standard prompts and reworded prompts.
Takeaway → The first three bars stand near 90 to 97 percent, but whole-program and executed-answer bars crater to about 22 and 3 percent: all twenty-four parts must land at once.
Data table
| program component | standard L24 | paraphrase L24 |
|---|---|---|
| init | 91.4% | 89.1% |
| op | 97.3% | 92.5% |
| arg | 95.2% | 88.5% |
| program exact | 21.1% | 2.3% |
| executor exact | 21.9% | 3.1% |
Numbers from experiments/qwen_register_token_latent_compiler/analysis/final_metrics.csv
Technical framing
Where length-24 fails: per-component vs whole-program accuracy — At length 24 each program slot is still ~89-97% correct, but 24 slots must all be right, so exact-program and executor accuracy collapse.
How to read
The horizontal axis is training step (1 to 600); the vertical axis is executed-answer accuracy, higher is better. Four lines track chain lengths 4, 8, 12, and 24 as the curriculum lengthens the chains.
Takeaway → All lines hug zero until step 300, then short and medium lengths leap together toward 90 percent while length twenty-four crawls, reaching only 22 percent by the end.
Data table
| Training step | Length 4 | Length 8 | Length 12 | Length 24 |
|---|---|---|---|---|
| 1 | 2.3% | 0.8% | 1.6% | 3.1% |
| 150 | 0% | 0.8% | 0% | 1.6% |
| 151 | 0% | 0% | 2.3% | 2.3% |
| 300 | 2.3% | 0.8% | 0.8% | 0.8% |
| 301 | 2.3% | 0.8% | 0.8% | 0.8% |
| 450 | 59.4% | 56.2% | 64.1% | 2.3% |
| 451 | 60.2% | 58.6% | 67.2% | 8.6% |
| 600 | 88.3% | 94.5% | 94.5% | 21.9% |
Numbers from experiments/qwen_register_token_latent_compiler/runs/main_register_trace_s600/train_log.csv
Technical framing
Training curve: executor accuracy by chain length across curriculum stages — Accuracy stays near zero for 300 steps, then short/medium lengths jump together in the third stage while length 24 lags far behind.
How to read
One bar per development run in order — five earlier pilot configurations, then the main run. Height is standard twenty-four-step executed-answer accuracy, higher is better.
Takeaway → Five pilots all stalled at 0 to 3 percent; only the final 600-step curriculum run with adapters and step-by-step supervision reached 22 percent.
Data table
| Run (in development order) | Executor exact |
|---|---|
| Frozen pilot | 0% |
| Frozen inline pilot | 0% |
| LoRA pilot | 3.1% |
| LoRA named-register pilot | 0% |
| LoRA init-strong pilot | 0% |
| Main trace run | 21.9% |
Numbers from experiments/qwen_register_token_latent_compiler/analysis/summary.md table
Technical framing
Design iterations: only the final LoRA + trace recipe lifts length-24 accuracy — Five pilot configurations all stayed at 0-3% on standard length-24; only the final 600-step curriculum run reached 21.9%.
How to read
The horizontal axis is chain length; the vertical axis, higher is better, shows two rates on paired prompts: how often both phrasings reach the same hidden program, and how often both are correct.
Takeaway → Same-program agreement holds near 98 to 99 percent through twelve steps, while the both-correct rate runs lower and bumpier at 88 to 96 percent; at twenty-four both collapse near chance, about 3 and 2 percent: identical tasks now compile to different hidden programs.
Data table
| Chain length | Pair state consistency | Both of pair correct |
|---|---|---|
| 4 | 99.2% | 87.5% |
| 8 | 99.2% | 96.1% |
| 12 | 98.4% | 90.6% |
| 24 | 3.1% | 1.6% |
Numbers from experiments/qwen_register_token_latent_compiler/analysis/summary.md table
Technical framing
Paired-prompt consistency: same-program agreement collapses at length 24 — Two phrasings of the same task compile to matching register states 98-99% of the time through length 12, but only 3.1% at length 24.
In the author’s words from the Overview · “Result”
The main trace-supervised run learned a real register interface for short and medium chains, but did not solve robust length-24 generalization.
Overview
This standalone experiment tests whether a Qwen-attached model can write an executable modular-arithmetic program into a fixed bank of appended register tokens. A trainable bridge reads only those register hidden states, predicts an initial value plus per-step operations and arguments, and an invisible executor runs the predicted program modulo 97.
Result
The main trace-supervised run learned a real register interface for short and medium chains, but did not solve robust length-24 generalization.
| Split | Executor exact | Program exact | Init | Op | Arg | Pair both |
|---|---|---|---|---|---|---|
| Standard L4 | 88.3% | 88.3% | 88.3% | 100.0% | 100.0% | n/a |
| Standard L8 | 94.5% | 94.5% | 94.5% | 100.0% | 100.0% | n/a |
| Standard L12 | 94.5% | 94.5% | 94.5% | 100.0% | 100.0% | n/a |
| Standard L24 | 21.9% | 21.1% | 91.4% | 97.3% | 95.2% | n/a |
| Paraphrase L24 | 3.1% | 2.3% | 89.1% | 92.5% | 88.5% | n/a |
| Paired L24 | 12.5% | 12.1% | 92.2% | 94.7% | 92.4% | 1.6% |
Two controls stayed at chance under comparable budgets:
| Run | Standard L24 | Paraphrase L24 | Paired L24 |
|---|---|---|---|
| Direct answer head | 3.1% | 0.0% | 1.6% |
| Register answer-only | 1.6% | 0.0% | 0.0% |
Layout
experiments/qwen_register_token_latent_compiler/
src/ experiment and analysis scripts
reports/ experiment log and final writeup in Markdown/HTML
analysis/ regenerated CSVs, summary, and figures
runs/ per-run metrics and training logs, without large checkpoints
checkpoint_manifest.csv
large_artifacts/qwen_register_token_latent_compiler/checkpoints/
saved adapters and bridge headsReproduction
Main trace-supervised run:
python experiments/qwen_register_token_latent_compiler/src/qwen_register_token_latent_compiler_experiment.py \
--output_dir experiments/qwen_register_token_latent_compiler/runs/main_register_trace_s600 \
--checkpoint_dir large_artifacts/qwen_register_token_latent_compiler/checkpoints/main_register_trace_s600 \
--variants register_trace \
--register_style bare \
--curriculum_stages short:1:4:150,medium:1:8:150,train:1:12:150,long:8:24:150 \
--train_size 512 \
--answer_train_size 512 \
--eval_size 128 \
--eval_lengths 4,8,12,24 \
--train_batch_size 4 \
--eval_batch_size 8 \
--register_width 512 \
--register_layers 1 \
--register_heads 4 \
--head_width 512 \
--init_trace_loss_weight 4 \
--op_trace_loss_weight 1 \
--arg_trace_loss_weight 4 \
--eval_every 150 \
--stage_eval_every 150 \
--max_length 768 \
--lr 0.0002 \
--lora_r 8 \
--lora_alpha 16Regenerate analysis after runs:
python experiments/qwen_register_token_latent_compiler/src/analyze_qwen_register_token_latent_compiler.pyKey Files
reports/qwen_register_token_latent_compiler_experiment_log.mdreports/qwen_register_token_latent_compiler_paper.mdreports/qwen_register_token_latent_compiler_paper.htmlanalysis/summary.mdanalysis/all_final_metrics.csvcheckpoint_manifest.csv
Report
Rendered from reports/qwen_register_token_latent_compiler_paper.md
Abstract
This experiment tests whether a small Qwen-attached training intervention can make a fixed bank of latent register tokens act like an executable program surface. Each prompt describes a modular-arithmetic chain. The prompt is followed by marker tokens for an initial-value register and one operation and argument register per possible step. A trainable compiler reads only the hidden states at those register markers. It predicts a program, and a deterministic invisible executor runs that program modulo 97.
The result is mixed. With QLoRA adaptation and trace supervision, the model learns the register interface well through length 12: exact execution reaches 88.3-94.5% on standard prompts, 89.1-90.6% on paraphrased prompts, and 87.9-96.1% on paired renderings of the same program. At length 24, exact execution falls to 21.9% on standard prompts, 3.1% on paraphrases, and 12.5% on paired prompts. Per-slot accuracy remains high at length 24, but exact long-chain program correctness is brittle.
Two controls stayed near chance. A direct answer head trained on the answer marker reached only 3.1% on standard length 24. The same register compiler trained only from final-answer loss reached 1.6% on standard length 24 and 0.0% on paired length 24. The useful signal came from supervised executable traces, not from final-answer supervision alone.
Question
Can a Qwen-attached model learn to write an invisible executable program into a fixed register bank, where the downstream runtime reads only those register hidden states and never reads hand-selected prompt spans?
This is a strict interface test. The bridge sees:
- the hidden state at
<REG_INIT>; - the hidden state at each
<REG_OP_XX>; - the hidden state at each
<REG_ARG_XX>.
It does not receive token spans for the source numbers or operation words. If it works, the language model has learned to route source information into fixed latent program slots.
Task
Each example samples an initial value x modulo 97 and a chain of updates:
+x by a
-x by a
*x by aThe true answer is the final value after executing all active steps modulo 97. The maximum register bank has 24 steps. Evaluation uses lengths 4, 8, 12, and 24, with three rendering modes:
| Split | Meaning |
|---|---|
| Standard | Canonical prompt wording |
| Paraphrase | Alternative wording for the same operation semantics |
| Paired | Two renderings of each sampled program, used to measure consistency |
Model
The base model is Qwen/Qwen3-4B, loaded in 4-bit NF4 with LoRA adapters on linear modules. The main compiler is a one-layer transformer over the register bank:
- input: Qwen hidden states at register-marker positions;
- width: 512;
- heads: 4;
- outputs: one init distribution over 97 values, one operation distribution per step, and one argument distribution per step.
A deterministic differentiable executor maps the predicted distributions into a final answer distribution. Argmax execution is used for exact program metrics.
Training Variants
| Variant | Interface | Supervision |
|---|---|---|
| Direct answer head | Answer-marker hidden state | Final answer only |
| Register answer-only | Register hidden states | Final answer through soft executor |
| Register trace | Register hidden states | Init, operation, argument, and final answer |
The main run uses the register-trace variant. It trains for 600 optimizer steps with a curriculum: 150 steps on lengths 1-4, 150 on 1-8, 150 on 1-12, and 150 on 8-24.
Main Results
Trace-Supervised Register Compiler
| Split | Executor exact | Program exact | Init | Op | Arg | Prefix | Pair both | Pair state consistency |
|---|---|---|---|---|---|---|---|---|
| Standard L4 | 88.3% | 88.3% | 88.3% | 100.0% | 100.0% | 88.3% | n/a | n/a |
| Standard L8 | 94.5% | 94.5% | 94.5% | 100.0% | 100.0% | 94.5% | n/a | n/a |
| Standard L12 | 94.5% | 94.5% | 94.5% | 100.0% | 100.0% | 94.5% | n/a | n/a |
| Standard L24 | 21.9% | 21.1% | 91.4% | 97.3% | 95.2% | 83.9% | n/a | n/a |
| Paraphrase L4 | 90.6% | 90.6% | 90.6% | 100.0% | 100.0% | 90.6% | n/a | n/a |
| Paraphrase L8 | 91.4% | 91.4% | 91.4% | 100.0% | 100.0% | 91.4% | n/a | n/a |
| Paraphrase L12 | 89.1% | 89.1% | 89.1% | 100.0% | 100.0% | 89.1% | n/a | n/a |
| Paraphrase L24 | 3.1% | 2.3% | 89.1% | 92.5% | 88.5% | 72.9% | n/a | n/a |
| Paired L4 | 87.9% | 87.9% | 87.9% | 100.0% | 100.0% | 87.9% | 87.5% | 99.2% |
| Paired L8 | 96.1% | 96.1% | 96.1% | 100.0% | 100.0% | 96.1% | 96.1% | 99.2% |
| Paired L12 | 91.0% | 91.0% | 91.0% | 100.0% | 100.0% | 91.0% | 90.6% | 98.4% |
| Paired L24 | 12.5% | 12.1% | 92.2% | 94.7% | 92.4% | 79.5% | 1.6% | 3.1% |
The trace-supervised compiler clearly learns the latent register interface through length 12. It also learns many length-24 slots: init, op, and arg accuracies are all high on the standard length-24 split. But exact length-24 program execution is much lower, because a long chain needs every crucial slot and every intermediate transition to be right.
Controls
| Control | Standard L4 | Standard L8 | Standard L12 | Standard L24 | Paraphrase L24 | Paired L24 |
|---|---|---|---|---|---|---|
| Direct answer head | 1.6% | 1.6% | 1.6% | 3.1% | 0.0% | 1.6% |
| Register answer-only | 0.0% | 0.0% | 0.0% | 1.6% | 0.0% | 0.0% |
Modulo-97 chance is about 1.0%. These controls do not learn the task under the tested budgets. The answer-only register compiler does learn a stable but uninformative program pattern: paired consistency is high because both prompt renderings collapse to the same wrong registers.
Training Dynamics
The main run becomes useful only after enough curriculum exposure:
| Step | Standard L4 | Standard L8 | Standard L12 | Standard L24 | Paired L24 |
|---|---|---|---|---|---|
| 450 | 59.4% | 56.2% | 64.1% | 2.3% | 1.6% |
| 600 | 88.3% | 94.5% | 94.5% | 21.9% | 12.5% |
The last 150-step long-chain stage is responsible for the length-24 lift, but it does not produce prompt-invariant length-24 programs.
Interpretation
This is evidence that a local 4B-scale model can be trained to expose a program-like latent interface through fixed register tokens. The strongest result is not the length-24 score; it is the length-12 behavior combined with the failed controls. The bridge reads only register-marker states, yet it recovers complete executable programs for unseen examples and paraphrases.
The hard failure is compositional reliability. At length 24, per-slot accuracies near 90-97% are not enough. The product of many small slot errors destroys exact execution, and paired consistency shows that different prompt renderings do not land on the same latent state trajectory.
This points to a specific next direction: the register interface should be kept, but training should directly penalize long-chain trajectory errors and paired state disagreement. More final-answer-only optimization is unlikely to discover the interface by itself; the answer-only control is the clearest evidence for that.
Limitations
- The task is synthetic modular arithmetic, not open-domain language use.
- Trace supervision supplies privileged intermediate labels during training.
- The executor is fixed and exact; the experiment does not learn a general runtime.
- The main run is a single 600-step configuration, not a scaling study.
- Length-24 performance is not robust enough to call the method solved.
Artifacts
- Source, metadata, analysis, and reports:
experiments/qwen_register_token_latent_compiler/ - Checkpoints:
large_artifacts/qwen_register_token_latent_compiler/checkpoints/ - Aggregate metrics:
experiments/qwen_register_token_latent_compiler/analysis/all_final_metrics.csv - Main summary:
experiments/qwen_register_token_latent_compiler/analysis/summary.md
Experiment log 14
Show the running log (14 entries)
Objective
Train and evaluate a Qwen-attached latent compiler that uses a fixed appended register bank as its only program interface. The bridge may read register hidden states, but it may not read hand-selected numeric or operation spans from the prompt.
Success Criteria
- Keep the experiment standalone with its own source, reports, analysis, run metadata, and checkpoint manifest.
- Store large checkpoints under
large_artifacts/. - Run smoke, pilot, and main configurations rather than relying on one run.
- Evaluate direct answer prediction, answer-only register discovery, and trace-supervised register compilation where feasible.
- Report standard, paraphrase, and paired length generalization.
Runs
Smoke: Frozen Register Trace
smoke_frozen_register_trace
- Frozen
Qwen/Qwen3-4Bbackbone. - Four-step register bank, two optimizer steps, tiny train/eval sets.
- Purpose: validate appended register construction, register hidden-state extraction, bridge training, strict execution metrics, checkpoint writing, and analysis aggregation.
- Result: completed end to end. Accuracy was not expected to move under this tiny two-step setup.
Pilot: Frozen Full Register Trace
pilot_frozen_register_trace_s120
- Frozen
Qwen/Qwen3-4Bbackbone. - Full 24-step register bank.
- Trace-supervised bridge, 120 optimizer steps across lengths 1-12.
- Purpose: test whether the appended register positions already expose enough frozen-model information for a bridge to recover executable slots.
- Result: weak control. Fresh paired L24 exact execution was 1.6%, with 0.0% program exact and 0.0% paired state consistency. This indicates that the fixed register interface needs model adaptation, not only a trained readout.
Pilot: LoRA Full Register Trace
pilot_lora_register_trace_s180
- QLoRA-adapted
Qwen/Qwen3-4B. - Bare appended 24-step register bank.
- Trace-supervised bridge, 180 optimizer steps across lengths 1-12.
- Purpose: test whether a small model adaptation can route prompt information into appended register slots.
- Result: operation and argument extraction began to work, but the initial-value register did not. On standard L24, operation accuracy was 86.1% and argument accuracy was 73.0%, while init accuracy was 0.0%, executor exact was 3.1%, and program exact was 0.0%.
Pilot: Named Register Trace
pilot_lora_named_register_trace_s240
- QLoRA-adapted backbone.
- Semantically named appended register bank.
- Trace supervision with stronger init weighting.
- Purpose: test whether natural-language labels around each register slot make the latent interface easier to learn.
- Result: worse than the bare register bank. On standard L24, executor exact was 0.0%, operation accuracy was 31.6%, and argument accuracy was 3.5%.
Pilot: Bare Register Trace With Strong Init Weight
pilot_lora_bare_initstrong_s300
- QLoRA-adapted backbone.
- Bare appended register bank.
- Stronger init and argument trace weights.
- Purpose: test whether the initial-value failure could be fixed by reweighting the slot losses.
- Result: init improved only weakly and argument extraction regressed. On standard L24, executor exact was 0.0%, init accuracy was 3.1%, operation accuracy was 78.1%, and argument accuracy was 17.6%.
Pilot: Frozen Inline Register Trace
pilot_frozen_inline_register_trace_s120
- Frozen backbone.
- Register markers placed next to the source lines rather than only in a suffix bank.
- Purpose: diagnostic control for whether proximity to the prompt text is enough to make frozen register states linearly decodable.
- Result: still weak. On standard L24, executor exact and program exact were 0.0%; operation accuracy was 41.7% and argument accuracy was 5.3%.
Main: Bare Register Trace
main_register_trace_s600
- QLoRA-adapted backbone.
- Bare appended 24-step register bank.
- Trace-supervised compiler with a one-layer register transformer, width 512.
- Curriculum: 150 steps at lengths 1-4, 150 at 1-8, 150 at 1-12, and 150 at 8-24.
- Purpose: run the strongest register-interface configuration found by the pilots, with enough training for long-chain exposure.
Main final metrics:
| Split | Executor exact | Program exact | Init | Op | Arg | Prefix | Pair both | Pair state consistency |
|---|---|---|---|---|---|---|---|---|
| Standard L4 | 88.3% | 88.3% | 88.3% | 100.0% | 100.0% | 88.3% | n/a | n/a |
| Standard L8 | 94.5% | 94.5% | 94.5% | 100.0% | 100.0% | 94.5% | n/a | n/a |
| Standard L12 | 94.5% | 94.5% | 94.5% | 100.0% | 100.0% | 94.5% | n/a | n/a |
| Standard L24 | 21.9% | 21.1% | 91.4% | 97.3% | 95.2% | 83.9% | n/a | n/a |
| Paraphrase L24 | 3.1% | 2.3% | 89.1% | 92.5% | 88.5% | 72.9% | n/a | n/a |
| Paired L24 | 12.5% | 12.1% | 92.2% | 94.7% | 92.4% | 79.5% | 1.6% | 3.1% |
Interpretation: the register interface is trainable. The model learned to use the appended marker positions as a program-writing surface, because the same architecture without trace supervision stayed at chance. The long-chain result is not solved: high per-slot accuracy at L24 still compounds into poor exact program execution, especially under paraphrases and paired consistency.
Control: Register Answer-Only
control_register_answer_only_s300
- QLoRA-adapted backbone.
- Same bare appended register bank and compiler architecture.
- Trained only through the final soft-executor answer loss, with no trace targets.
- Purpose: test whether final-answer supervision alone can discover the register program interface.
- Result: no. Standard L24 executor exact was 1.6%, paraphrase L24 was 0.0%, paired L24 was 0.0%, and program exact was 0.0% on all length-24 splits.
Control: Direct Answer Head
control_direct_answer_s300
- QLoRA-adapted backbone.
- No register compiler.
- A direct MLP head reads the answer-marker hidden state and predicts the final value modulo 97.
- Purpose: test whether the base hidden state plus a small supervised head can solve the same answer task under a comparable training budget.
- Result: no. Standard L24 direct accuracy was 3.1%, paraphrase L24 was 0.0%, and paired L24 was 1.6%.
Interpretation
The experiment gives a narrow positive result and a clear bottleneck.
The positive result is that a fixed appended register bank can become a latent program interface when Qwen is adapted with LoRA and supervised with executable slot traces. The main run reached 88.3-94.5% exact execution through length 12 on standard prompts, 89.1-90.6% on paraphrase prompts through length 12, and 87.9-96.1% paired execution through length 12.
The bottleneck is long-chain reliability. At length 24 the compiler still predicts most individual slots correctly, but exact program correctness falls to 21.9% on standard prompts, 3.1% on paraphrases, and 12.5% on paired prompts. The paired state-consistency metric falls to 3.1%, so the long-chain register states are not yet prompt-invariant.
Final-answer-only learning is not enough here. Both the direct answer head and the answer-only register compiler remained near modulo-97 chance. Trace supervision is the difference between learning a register program and failing to discover the interface.
Artifacts
- Small files:
experiments/qwen_register_token_latent_compiler/ - Large checkpoints:
large_artifacts/qwen_register_token_latent_compiler/checkpoints/
Figures 4
Data files 20
Result tables and metrics copied from the experiment folder — preview inline or open the raw file.
analysis/all_final_metrics.csv18 kBanalysis/final_metrics.csv2.5 kBruns/control_direct_answer_s300/metrics.csv1.8 kBruns/control_direct_answer_s300/results.json41 kBruns/control_register_answer_only_s300/metrics.csv2.7 kBruns/control_register_answer_only_s300/results.json46 kBruns/main_register_trace_s600/metrics.csv2.5 kBruns/main_register_trace_s600/results.json84 kBruns/pilot_frozen_inline_register_trace_s120/metrics.csv2.6 kBruns/pilot_frozen_inline_register_trace_s120/results.json64 kBruns/pilot_frozen_register_trace_s120/metrics.csv2.4 kBruns/pilot_frozen_register_trace_s120/results.json64 kBruns/pilot_lora_bare_initstrong_s300/metrics.csv2.5 kBruns/pilot_lora_bare_initstrong_s300/results.json64 kBruns/pilot_lora_named_register_trace_s240/metrics.csv2.5 kBruns/pilot_lora_named_register_trace_s240/results.json64 kBruns/pilot_lora_register_trace_s180/metrics.csv2.5 kBruns/pilot_lora_register_trace_s180/results.json64 kBruns/smoke_frozen_register_trace/metrics.csv1.2 kBruns/smoke_frozen_register_trace/results.json16 kB
Reproduce
The run commands are documented inside the experiment folder (see the README).