txgsync/muse-k2-vision-pilot-20260910

Muse → K2 bridge: first training experiment

Prepared September 10, 2026. This experiment tests whether training a connector lets the frozen IFM/K2-Horizon-7B decoder use the existing Muse-Glimmer visual encoder. It does not retrain the vision encoder or K2, and it does not establish general screenshot, document, natural-image, or visual reasoning capability.

Authorized budget and selected first hardware

The user authorized an initial inexpensive Hugging Face experiment against an existing $21.83 compute balance and available public storage. HF's hardware API quotes L4 24 GB at $0.013333/minute, approximately $0.80/hour. The first planned job has a three-hour timeout: approximately $2.40 maximum compute. Training has an earlier internal two-hour limit to reserve time for evaluation and export. Setup and model download count against the job timeout. No exposed ports, persistent paid bucket, scheduled jobs, or paid teacher model are required.

L4 is the cheapest plausible BF16 option: T4 16 GB cannot contain K2's 18 GB weights alone. L4's actual CUDA memory fit and throughput must be measured. If it cannot execute the prepared experiment, record the failed attempt and choose a roomier GPU explicitly; do not silently quantize, offload, alter the model, or claim the failed launch produced training results. Total expenditure must remain within existing credit. No larger follow-on training is authorized as part of this initial experiment.

Sources: HF hardware pricing, Jobs configuration.

Model and learning mechanism

448 × 224 RGB image
  → frozen Muse tower and original patch merge
  → 128 × 6144 BF16 features, computed on the Mac
  → trainable Linear(6144,4096), GELU, Linear(4096,4096), GELU
  → trainable Linear(4096,4096)
  → inserted between image delimiters in K2's input embedding sequence
  → frozen K2 decoder
  → cross entropy on answer tokens and end-of-message token

The first two matrices come from Muse's released adapter. The last is initialized as a scaled identity, gain 0.33, chosen before training from the previous local probe's approximate embedding/adapter magnitudes (0.0349 vs roughly 0.1). This initialization is not a learned alignment. All three matrices learn: 58,720,256 parameters. Their optimizer parameters/moments are FP32 and matrix computations use BF16 autocast. The decoder remains BF16 and all of its parameters have requires_grad=False.

Frozen decoder weights still participate in differentiable computation: gradients must travel through the decoder back to the bridge. Using no_grad around the decoder during training would break this experiment. Only frozen text embeddings and vision feature extraction may be detached. Non-reentrant activation checkpointing and SDPA reduce memory. We compute vocabulary logits only at the correctly shifted answer positions, avoiding a large image-token by vocabulary allocation.

K2 source is an unmodified local copy from revision 586b03f0fd1fbbf2f13eeafc33749e95ae34dd10; hashes are in vendor/provenance.json. Explicit local imports avoid Transformers' dynamic module loader resolving relative source imports against HF cache blob symlinks, a failure caught by the first CPU check. Original Apache-2.0 notices are retained. Muse revision and extracted-weight SHA-256 are in data/preparation.json.

Data and controls, chosen before training

Seed: 20260910. Synthetic, generated images; no personal files or paid labels. All images are 448 × 224 and use Muse's original image processor. Each image has 128 visual tokens. prepare.py checks duplicate image hashes across all splits.

Split	Color	Count	Word	Total
Training	512	512	512	1,536
Validation	64	64	64	192
Held-out images	96	96	96	288
Held-out words	—	—	64	64

Colors have four balanced classes, counts are one through four, and training words have sixteen classes. Test images vary backgrounds, sizes, positions, and fonts drawn from the same rendering distribution. The 64 novel-word tests use sixteen words never used in training. Fonts are Arial Bold, Courier New Bold, and Verdana Bold. Rendered images are shared; system font files are not.

All examples within a task use the same question. Image IDs, filenames, labels, and split membership are never included in the model prompt. Answers are open text, without a fixed list of answer choices. Evaluation uses greedy generation, at most eight tokens, with case and terminal-period/exclamation normalization. The response begins after K2's low-effort thinking close tag and its required newline, matching the corrected frozen experiment's answer boundary.

Before and after training, evaluate all 352 held-out images. Record blank-image predictions and a cyclic wrong-image permutation within every split/task. Because prompts within a task are identical, the donor image's existing output is exactly the wrong-image inference; no extra GPU pass is necessary. Every donor has a different answer. This permutation preserves class balance. The validation subset during training has sixteen examples per task (48 total). Test results do not select checkpoints or hyperparameters.

Training limits and verification

Initial learning rate 1e-4, linear 20-step warm-up, AdamW, no weight decay, gradient clipping at norm 1, microbatch one, four accumulated examples per optimizer step. Train at most two epochs / 768 optimizer steps, subject to the earlier wall-clock limit. No training-time data augmentation follows caching.

verify_local.py uses actual K2 classes at tiny dimensions on CPU to check answer-loss equivalence against full causal logits, gradients through the checkpointed decoder, a decreasing optimization loss, and bitwise unchanged frozen parameters. train.py --mode smoke --device mps then checks the real checkpoint's external embedding equivalence and nonzero gradients in all three bridge matrices. Full-model checks require absent decoder gradients and compare sampled values from every frozen tensor; these samples alone are not a full checksum of all decoder weights.

Each exported bridge is verified for an exact BF16 save/load round trip. Final cloud evaluation reloads that exported bridge before scoring. The artifact is also intended to be downloaded and checked on the Mac. Record actual GPU, memory, throughput, initial/final held-out outputs, steps completed, failure logs if any, model/data revisions, elapsed job time, and estimated billed cost.

Interpretation

Decreasing loss proves optimization, not vision generalization. Improved held-out colors/counts show that the bridge can transmit simple visual facts. Accuracy materially above blank/wrong-image controls supports image dependence. Reading unseen words is stronger evidence than selecting among learned words. Even a successful result on this dataset would leave natural images, documents, screenshots, spatial reasoning, instruction diversity, and text-only behavior to be evaluated separately. A failed result is also a valid first experiment; report the evidence and stop to discuss next steps.

Completed local preparation

The Mac encoded 2,081 images (including a blank control) in 409.3 seconds, peaking at 4.218 GB MLX allocation. The cached features plus initial bridge use 3.391 GB. The CPU causal-loss/gradient tests passed: a tiny frozen K2 decreased loss from 4.894 to 4.172 across 60 bridge updates, with every frozen weight bitwise unchanged. The initialized Torch bridge agrees with the prior MLX adapter times 0.33 to 1.07% relative L2 error under BF16 rounding.

The full BF16 K2 forward/backward smoke check took about 11 seconds including loading. Text/external-embedding logits were identical, all bridge matrices had finite nonzero gradients, and all decoder gradients were absent. Post-backward MPS allocation was 18.526 GB; this is not a CUDA peak measurement.

Accelerate 1.15.0 is installed in local-deps/ solely for this experiment; Transformers requires it for loading directly to a selected device. The existing oMLX environment was not modified. The cloud image is PyTorch 2.9.1 with CUDA 12.8, pinned by digest, with Transformers 5.12.1, HF Hub 1.30.0, Safetensors 0.8.0, and Accelerate 1.15.0. Local Torch is 2.14.0; CUDA smoke verification is mandatory before training because the backends and Torch versions differ.

No full-model training results exist at preparation time. Completed results and exact job identifiers will be recorded in a separate results report.

Additional records: local preparation and broader HF dataset options.