run record~/research/cliste/runsAll Cliste runs

Type a section name and press Enter. Use “help” for the list.

Figures: softened for dark viewingDisplay only; image files are unchanged.
← All Cliste runs

Cliste experiment

Native perceptual continuation and retained memory

Execution: failedScientific verdict: No final scientific verdict

The question

Improve native visual encoding and decoding through broader experience while measuring whether continued learning preserves previously stored VSA percepts.

Why this experiment?

A memory can only preserve what its sensory interface encodes. These studies separate encoder quality, decoder quality and compatibility with earlier stored vectors.

How it works

Change one component or input representation at a time and evaluate immediate reconstruction on separate images. Keep old-vector readback visible so gains on new inputs do not hide compatibility losses.

Follow this part of the investigation: Sharper perception can also change the language of memory →
Implementation and comparison details

Continue the development-selected joint codec using broader photographs at native dimensions and aspect ratios. Compare ordinary joint refinement with matched continuation plus replay toward archived readback of stored VSA vectors. Separate acquisition, replay training, development selection and held-out retained memories. Measure fresh quality, old-vector readback, retrieval, exposure and resource costs; original acquisition identities and earlier lives remain intact.

What happened

Execution failed during evaluate: ValueError('isolation device must be cpu or cuda'); preserve evidence.

Results and visual artifacts

Open a figure for its input, comparison, and result. Click an image to enlarge it.

This experiment trains an image encoder and decoder on more visual experience while checking what happens to older vector memories. “Ordinary” learns from new images only; “replay” also rehearses decoding old vectors toward their earlier decoded images. Replay targets are imperfect reconstructions, not original photographs. Seeds 401–403 are repeated training trials; seed 402 was chosen in advance for final illustrations. An optimizer update is one training step. MSE means mean squared RGB pixel error, where lower is better. Development images guide method choices; final test images measure the locked comparison. Error panels use a fixed fourfold display scale, separate from the numerical scores. Training completed, but this attempt failed when final evaluation rejected a CUDA device-name string. These figures are development evidence only; a separate recovery evaluates the same locked models. Their presence does not turn this failed execution into a completed final comparison.

The fixed development images used to track training
The fixed development images used to track training
These six source images are evaluation references, not model outputs. They keep the same order throughout the training-progress sheets so a change in the reconstruction can be compared against the same scene. The dimensions describe the original rectangular input; each picture is resized only to fit this page.
Training with memory rehearsal: new-image reconstruction after 500 updates (replay-weight pilot 1)
Training with memory rehearsal: new-image reconstruction after 500 updates (replay-weight pilot 1)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results. Pilot weight 1 multiplies the replay loss relative to the fresh-image loss; it is not a number of replayed images.
Training with memory rehearsal: old-memory readback after 500 updates (replay-weight pilot 1)
Training with memory rehearsal: old-memory readback after 500 updates (replay-weight pilot 1)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results. Pilot weight 1 multiplies the replay loss relative to the fresh-image loss; it is not a number of replayed images.
Learning sharper new images while preserving old vector memories
Learning sharper new images while preserving old vector memories
Horizontal axes count training updates; each line is one method and training seed, with short pilot lines testing replay weights 1, 4 and 16. Left: reconstruction MSE on new development images, where lower is better. Middle: percentage change in old-memory reconstruction error relative to its acquisition value; zero preserves the original error, negative improves it, and the dashed red line is the provisional +2% development tolerance. Right: MSE between current and original decodings of the same old vectors, where zero means unchanged rendering. Low rendering drift can also preserve old decoding errors. These are development curves, not final test results. Replay rehearses saved vectors against their earlier decodings. The interrupted attempt and recovery share these recorded training histories; they are not independent training repetitions.

Original recorded figure ↗

Training with memory rehearsal: new-image reconstruction after 500 updates (replay-weight pilot 4)
Training with memory rehearsal: new-image reconstruction after 500 updates (replay-weight pilot 4)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results. Pilot weight 4 multiplies the replay loss relative to the fresh-image loss; it is not a number of replayed images.
Training with memory rehearsal: old-memory readback after 500 updates (replay-weight pilot 4)
Training with memory rehearsal: old-memory readback after 500 updates (replay-weight pilot 4)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results. Pilot weight 4 multiplies the replay loss relative to the fresh-image loss; it is not a number of replayed images.
Training with memory rehearsal: new-image reconstruction after 500 updates (replay-weight pilot 16)
Training with memory rehearsal: new-image reconstruction after 500 updates (replay-weight pilot 16)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results. Pilot weight 16 multiplies the replay loss relative to the fresh-image loss; it is not a number of replayed images.
Training with memory rehearsal: old-memory readback after 500 updates (replay-weight pilot 16)
Training with memory rehearsal: old-memory readback after 500 updates (replay-weight pilot 16)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results. Pilot weight 16 multiplies the replay loss relative to the fresh-image loss; it is not a number of replayed images.
Training on new images only: new-image reconstruction after 1,000 updates (trial seed 401)
Training on new images only: new-image reconstruction after 1,000 updates (trial seed 401)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: old-memory readback after 1,000 updates (trial seed 401)
Training on new images only: old-memory readback after 1,000 updates (trial seed 401)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: new-image reconstruction after 2,000 updates (trial seed 401)
Training on new images only: new-image reconstruction after 2,000 updates (trial seed 401)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: old-memory readback after 2,000 updates (trial seed 401)
Training on new images only: old-memory readback after 2,000 updates (trial seed 401)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: new-image reconstruction after 3,000 updates (trial seed 401)
Training on new images only: new-image reconstruction after 3,000 updates (trial seed 401)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: old-memory readback after 3,000 updates (trial seed 401)
Training on new images only: old-memory readback after 3,000 updates (trial seed 401)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: new-image reconstruction after 4,000 updates (trial seed 401)
Training on new images only: new-image reconstruction after 4,000 updates (trial seed 401)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: old-memory readback after 4,000 updates (trial seed 401)
Training on new images only: old-memory readback after 4,000 updates (trial seed 401)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: new-image reconstruction after 5,000 updates (trial seed 401)
Training on new images only: new-image reconstruction after 5,000 updates (trial seed 401)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: old-memory readback after 5,000 updates (trial seed 401)
Training on new images only: old-memory readback after 5,000 updates (trial seed 401)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: new-image reconstruction after 6,000 updates (trial seed 401)
Training on new images only: new-image reconstruction after 6,000 updates (trial seed 401)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: old-memory readback after 6,000 updates (trial seed 401)
Training on new images only: old-memory readback after 6,000 updates (trial seed 401)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: new-image reconstruction after 1,000 updates (trial seed 401)
Training with memory rehearsal: new-image reconstruction after 1,000 updates (trial seed 401)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: old-memory readback after 1,000 updates (trial seed 401)
Training with memory rehearsal: old-memory readback after 1,000 updates (trial seed 401)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: new-image reconstruction after 2,000 updates (trial seed 401)
Training with memory rehearsal: new-image reconstruction after 2,000 updates (trial seed 401)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: old-memory readback after 2,000 updates (trial seed 401)
Training with memory rehearsal: old-memory readback after 2,000 updates (trial seed 401)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: new-image reconstruction after 3,000 updates (trial seed 401)
Training with memory rehearsal: new-image reconstruction after 3,000 updates (trial seed 401)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: old-memory readback after 3,000 updates (trial seed 401)
Training with memory rehearsal: old-memory readback after 3,000 updates (trial seed 401)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: new-image reconstruction after 4,000 updates (trial seed 401)
Training with memory rehearsal: new-image reconstruction after 4,000 updates (trial seed 401)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: old-memory readback after 4,000 updates (trial seed 401)
Training with memory rehearsal: old-memory readback after 4,000 updates (trial seed 401)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: new-image reconstruction after 5,000 updates (trial seed 401)
Training with memory rehearsal: new-image reconstruction after 5,000 updates (trial seed 401)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: old-memory readback after 5,000 updates (trial seed 401)
Training with memory rehearsal: old-memory readback after 5,000 updates (trial seed 401)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: new-image reconstruction after 6,000 updates (trial seed 401)
Training with memory rehearsal: new-image reconstruction after 6,000 updates (trial seed 401)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: old-memory readback after 6,000 updates (trial seed 401)
Training with memory rehearsal: old-memory readback after 6,000 updates (trial seed 401)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: new-image reconstruction after 1,000 updates (trial seed 402)
Training with memory rehearsal: new-image reconstruction after 1,000 updates (trial seed 402)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: old-memory readback after 1,000 updates (trial seed 402)
Training with memory rehearsal: old-memory readback after 1,000 updates (trial seed 402)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: new-image reconstruction after 2,000 updates (trial seed 402)
Training with memory rehearsal: new-image reconstruction after 2,000 updates (trial seed 402)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: old-memory readback after 2,000 updates (trial seed 402)
Training with memory rehearsal: old-memory readback after 2,000 updates (trial seed 402)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: new-image reconstruction after 3,000 updates (trial seed 402)
Training with memory rehearsal: new-image reconstruction after 3,000 updates (trial seed 402)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: old-memory readback after 3,000 updates (trial seed 402)
Training with memory rehearsal: old-memory readback after 3,000 updates (trial seed 402)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: new-image reconstruction after 4,000 updates (trial seed 402)
Training with memory rehearsal: new-image reconstruction after 4,000 updates (trial seed 402)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: old-memory readback after 4,000 updates (trial seed 402)
Training with memory rehearsal: old-memory readback after 4,000 updates (trial seed 402)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: new-image reconstruction after 5,000 updates (trial seed 402)
Training with memory rehearsal: new-image reconstruction after 5,000 updates (trial seed 402)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: old-memory readback after 5,000 updates (trial seed 402)
Training with memory rehearsal: old-memory readback after 5,000 updates (trial seed 402)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: new-image reconstruction after 6,000 updates (trial seed 402)
Training with memory rehearsal: new-image reconstruction after 6,000 updates (trial seed 402)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: old-memory readback after 6,000 updates (trial seed 402)
Training with memory rehearsal: old-memory readback after 6,000 updates (trial seed 402)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: new-image reconstruction after 1,000 updates (trial seed 402)
Training on new images only: new-image reconstruction after 1,000 updates (trial seed 402)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: old-memory readback after 1,000 updates (trial seed 402)
Training on new images only: old-memory readback after 1,000 updates (trial seed 402)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: new-image reconstruction after 2,000 updates (trial seed 402)
Training on new images only: new-image reconstruction after 2,000 updates (trial seed 402)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: old-memory readback after 2,000 updates (trial seed 402)
Training on new images only: old-memory readback after 2,000 updates (trial seed 402)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: new-image reconstruction after 3,000 updates (trial seed 402)
Training on new images only: new-image reconstruction after 3,000 updates (trial seed 402)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: old-memory readback after 3,000 updates (trial seed 402)
Training on new images only: old-memory readback after 3,000 updates (trial seed 402)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: new-image reconstruction after 4,000 updates (trial seed 402)
Training on new images only: new-image reconstruction after 4,000 updates (trial seed 402)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: old-memory readback after 4,000 updates (trial seed 402)
Training on new images only: old-memory readback after 4,000 updates (trial seed 402)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: new-image reconstruction after 5,000 updates (trial seed 402)
Training on new images only: new-image reconstruction after 5,000 updates (trial seed 402)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: old-memory readback after 5,000 updates (trial seed 402)
Training on new images only: old-memory readback after 5,000 updates (trial seed 402)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: new-image reconstruction after 6,000 updates (trial seed 402)
Training on new images only: new-image reconstruction after 6,000 updates (trial seed 402)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: old-memory readback after 6,000 updates (trial seed 402)
Training on new images only: old-memory readback after 6,000 updates (trial seed 402)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: new-image reconstruction after 1,000 updates (trial seed 403)
Training on new images only: new-image reconstruction after 1,000 updates (trial seed 403)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: old-memory readback after 1,000 updates (trial seed 403)
Training on new images only: old-memory readback after 1,000 updates (trial seed 403)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: new-image reconstruction after 2,000 updates (trial seed 403)
Training on new images only: new-image reconstruction after 2,000 updates (trial seed 403)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: old-memory readback after 2,000 updates (trial seed 403)
Training on new images only: old-memory readback after 2,000 updates (trial seed 403)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: new-image reconstruction after 3,000 updates (trial seed 403)
Training on new images only: new-image reconstruction after 3,000 updates (trial seed 403)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: old-memory readback after 3,000 updates (trial seed 403)
Training on new images only: old-memory readback after 3,000 updates (trial seed 403)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: new-image reconstruction after 4,000 updates (trial seed 403)
Training on new images only: new-image reconstruction after 4,000 updates (trial seed 403)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: old-memory readback after 4,000 updates (trial seed 403)
Training on new images only: old-memory readback after 4,000 updates (trial seed 403)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: new-image reconstruction after 5,000 updates (trial seed 403)
Training on new images only: new-image reconstruction after 5,000 updates (trial seed 403)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: old-memory readback after 5,000 updates (trial seed 403)
Training on new images only: old-memory readback after 5,000 updates (trial seed 403)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: new-image reconstruction after 6,000 updates (trial seed 403)
Training on new images only: new-image reconstruction after 6,000 updates (trial seed 403)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training on new images only: old-memory readback after 6,000 updates (trial seed 403)
Training on new images only: old-memory readback after 6,000 updates (trial seed 403)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: new-image reconstruction after 1,000 updates (trial seed 403)
Training with memory rehearsal: new-image reconstruction after 1,000 updates (trial seed 403)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: old-memory readback after 1,000 updates (trial seed 403)
Training with memory rehearsal: old-memory readback after 1,000 updates (trial seed 403)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: new-image reconstruction after 2,000 updates (trial seed 403)
Training with memory rehearsal: new-image reconstruction after 2,000 updates (trial seed 403)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: old-memory readback after 2,000 updates (trial seed 403)
Training with memory rehearsal: old-memory readback after 2,000 updates (trial seed 403)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: new-image reconstruction after 3,000 updates (trial seed 403)
Training with memory rehearsal: new-image reconstruction after 3,000 updates (trial seed 403)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: old-memory readback after 3,000 updates (trial seed 403)
Training with memory rehearsal: old-memory readback after 3,000 updates (trial seed 403)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: new-image reconstruction after 4,000 updates (trial seed 403)
Training with memory rehearsal: new-image reconstruction after 4,000 updates (trial seed 403)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: old-memory readback after 4,000 updates (trial seed 403)
Training with memory rehearsal: old-memory readback after 4,000 updates (trial seed 403)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: new-image reconstruction after 5,000 updates (trial seed 403)
Training with memory rehearsal: new-image reconstruction after 5,000 updates (trial seed 403)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: old-memory readback after 5,000 updates (trial seed 403)
Training with memory rehearsal: old-memory readback after 5,000 updates (trial seed 403)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: new-image reconstruction after 6,000 updates (trial seed 403)
Training with memory rehearsal: new-image reconstruction after 6,000 updates (trial seed 403)
Each row shows a fixed development image, its current encode-and-decode reconstruction, and its pixel error. The whole original-size image is processed; the thumbnail is only a display. Compare the same scene across training steps to see acuity change. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.
Training with memory rehearsal: old-memory readback after 6,000 updates (trial seed 403)
Training with memory rehearsal: old-memory readback after 6,000 updates (trial seed 403)
Each row holds the old vector fixed. Columns show the original photograph, its reconstruction at acquisition, the current decoder’s reconstruction of that same vector, then the two errors against the photograph. This tests whether decoder training changes the meaning of a stored representation. Error panels show the absolute RGB difference from the reference, multiplied by four and clipped for display: black means a match; brighter colors mean larger pixel differences. The scale is the same across panels. These are development examples, not unseen final-test results.

Limits and next question

Both arms refine the same joint native codec. Replay targets are archived old-decoder outputs, not original RGB truth, and preserving those outputs can preserve their errors. Retention training, development and final cohorts have separate roles; held-out retention is known acquired experience, while fresh final photographs measure new-input quality. Source-free cross-version readback explicitly retains acquisition and current decoder identities; it does not establish automatic codec compatibility. Geometry and spatial bindings are supplied sensory structure. Each complex128 region costs 256 KiB before overlap and other state; report bytes, exposure, replay overhead, latency and peak memory. Earlier lives retain their original models; no candidate is installed. Reconstruction, retention and measured retrieval remain separate from reading, learned meaning or general cognition.

Next question. Use fresh-percept quality, held-out retained readback, retrieval and resource costs to choose further perceptual learning or compatibility work before continuing-life adoption.

Inspect the evidence

Download the methods and measurements for this experiment. Large training and saved-state files are not included.