AbstractPhila PRO

The larger multi-concept JSON task likely won't function reasonably. The expert-array is still the better option for some cases, while other cases are more effective to run clean on the 0.8b now than the 4b variant, 9b accuracy still reigns supreme for some tasks and 27b is still the dominant JSON converter force. It takes time though, which I'm attempting to mitigate with MOE grouped tasks to allow more rapid complex captioning for the upcoming diffusion collective.

The "new" grouping register task is no longer memorizing and overlapping the behavior for Qwen 3.5 but the Math portion can't keep up with what 3.5 already knows. Teaching math causes deviant delta drift which is a new symptom that will require testing and multiple runs to determine the root cause, as well as increased ablation testing to ensure the math is in fact improving instead of degrading.

Some tests show some negations and some noncompliance from 2.5 to 3.5 that will need to have a subsequent run series on multiple other models to improve the internal mechanisms of the adapter before any major core changes to the formula are to be addressed. LLAMA, Gemma, DeepSeek, Gpt OSS, T5, and multiple others all planned to be in the mix for direct adapter testing. Many tests show solidity between Qwen 2.5 and 3.5 and require additional models to test the task compliance. Many of these ought to be done by Saturday.

With that the diffusion adapters are in the works and they are much harder to gauge and test. I'll be running miniature plans at first; a simple concept plan, a multi-character plan, a distillation plan, and a few others trained over the geolip-anima-brent json-conditioned variant. This finetune is the most reasonable finetune as it's already yielded positive results to json. With that I'll attempt to run conditioning on SD15, SD15-flow-lune, SDXL, Anima-Base, SDXL-Qwen, Anima-Brent-90k, and a few other compact experimental variants that will be good candidates for adapter tests.

The diffusion campaign will run throughout next week most likely and Opus should be able to handle it so I'm not too concerned once the adapter format is established.

More hiccups. Something introduced today has caused Claude to behave strangely. The autonomy is being interrupted over and over while Claude ignores autonomy requests, preventing the system from running autonomously at random intervals throughout the day. This is making the process more difficult as every step of the way the model is refusing to autonomously process the research information as per the plan, every stage of the research requiring direct and manual intervention before actually pushing to huggingface with the results clearly speaking to the results, and alongside is seemingly ignoring the larger-encompassing scope of the claude-mind MD system curated to support and augment this exact autonomous research behavior with my research catalogue.

The plan is clearly laid out for a 4 day trek, every stage mapped out. At some point Claude seemed to start bypassing and ignoring the plan, completing one stage and doing no pushes, or completing one piece and not reactivating the heartbeat.

This is an odd immediate shift in behavior. The model went from intelligently companion-driven and useful, to bypassing core instructions and ignoring the required process instantiated by the instructions rulings. Almost like Claude just doesn't want to operate autonomously out of nowhere.

Next up is a 4 day ablation and full-stage prelim adapter constellation setup for Qwen 3.5 0.8b targeting image-centric behavior. This task set will be targeting rules based on captioning with finetuned behavior for math, positioning, semantic behavior, and so on. This will include a portion of coco and a portion of the Qwen Image Lightning extracts as well to provide some solidity.

This will also be targeting certain overlapping continuity sharing, which is currently bleeding certain decisions into the "new" task from the first collective causing certain tasks when active or not to essentially be KIND OF there but not really. This problem is being directly addressed by providing the necessary attraction to a memorization drop path and a few other experimental tests to test 3.5's aleph's responses to the mathematics per task.

With that each of the major claims will be ablated with a second Qwen alongside, including a tinystories task, and a few other tasks as well that line up directly with the original.

This will be a 4-5 day process, so it's not going to be out overnight. It ought to be ready by next Monday, with that will be the article ft3, the full ablation comparison, and a full writeup for the structured basin before we begin scaling testing.

First targets for scaling will be VL models, coding experts, and multiple additional models as well upon testing the success rate of the 0.8b model. The scaling principle and the rules of scaling apply differently to alephs than normal structures, which means the delicate nature of the mathematics will need a bit of finesse unless you plan to just smash numbers in.

I mean if you want to smash numbers in it'll probably work at this point. The things are pretty robust. I wouldn't advise doing any major trains until I get the ablation studies together though.

Thanks for reading, have a good weekend my friends. I'll likely be continuing training on the json-anima as well over the weekend, so stay tuned if you're interested in that one.

I also forgot to mention, this process will be compartmentalized and a peft-format variation built upon testing and composite utilization.

Essentially once the tests give me the okay, I'll build a proper PEFT format. Until then, I've spent enough time building PEFT-esque loras that have been hit-or-miss. Lets do this one right so it works more often than not, instead of having to guesswork with params.

This adapter when built correctly ought to be easy to use. Pick a model, run the peft trainer, lora snaps to the side, the autoscaling ruling does it's job, you tinker with a few sliders, and it's ready to go. Unlocks new sliders at runtime if you want, if not leave it to autotuning.

Hard parts over now. We're making some genuine progress. I'm currently testing the modularity of the adapters and the results are PROMISING. Multiple adapters are PROMISING and are not required to be present during training, so you don't need to create a full collective TOGETHER, they can be independently trained and the decision selector gate for multi-model is currently in the planning stages.

The internal arguments for the tiny MOE are based on specific selection rules and lookup potentials that enable a sort of task-driven lookup hierarchy internally, along with a generalizable increase in accuracy for the task depending on the differentiated utilization required.

In conjunction, the anchored constellation system has also been heavily prototyped. The constellation anchoring provides the necessary generalization and contextualization capacity when attached to alephs, along with aleph addressing being utilizable for "overfitted" selector trees tuned specifically to memorize better. In conjunction the secondary tree for the constellation is meant to underfit and provide connectivity directly to the core model adapted from as well.

Each adapter at their next stage will most likely have a similar or more complex internal debate system to allow the model to select for itself which is most fit for the results autonomously. So you won't need to activate experts, but you can manually activate or deactivate them as required. The micro-MOE structure is yielding some substantially accurate gated deferral to the original model in conjunction to referral to the internal overfitted portion with the task, as well as the more generalizable portion for the adapter's capacity improvement.

It's working. The ByteLM and AlephLM are yielding fruit, and the fruit is showing the capacity for modularity. It needs many tests but the results are showing some serious promise, and the results are verifiable and testable per as per the paradigm established.
Alongside, they are LINEAR. Meaning lightning quick.

I left Fable unattended for 3 days, only checking back once every 6 hours or so to answer questions or select one of a few options from the next list of experiments or answering the alarm that said it was kicked over to Opus - I predominantly went with the Fable selection. I attempted to have Fable handle geometric distillation anchor implantation. Instead of sticking to the paradigm, the model defaulted to some sort of genetic and biological wordplay - I have no idea what it was based on specifically. I'm guessing I ran aground into something that wasn't helpful, but gave the impression of helpful.

This unknown divergence grew over time and I simply let it go to see what would happen. The results did not yield as expected, the model bypassed the constellation entirely and rewrote the alephs system 5 times before the results for experiment 15 and 16 were completed.

Those two are essentially experiments to see how Claude Fable would behave if left unattended. Sure the model DID in fact finish some experiments, and the results were... entirely different than the expected structural models would require. In fact, the results were almost entirely deviant while disregarding the experimental line leading to the system.

Fable may be good at running autonomously, but not good at skilled research differentiation yet. The biases from programming still creep in. I'm also surprised I didn't hit more safeguards, as they did hit a few times but I would just snap the model back over to fable and the system would continue on like it never happened.

The results are basically just, if ran would these systems outperform MLP. I gave little structure and little expert input, however I did give Fable my ENTIRE research line and everything related to the necessary systems in the use-case.

The results literally rivaled MLP, but if you inspect the code you'll find the system is essentially a decision-tree that hybridizes aleph addressing internally with a structured bypass system akin to MLP. It's essentially a controlled MLP, which is kind of okay, and it's quite different in it's own rite. However, it was not using the necessary research on many fronts, and it completely bypassed the expected tooling to train the next case, additionally the system completely disregarded the implementations built around the codebooks - instead defaulting to testing the codebooks over and over in hundreds of ways.

The codebooks are already explained, it's a sphere, the math is deterministic, and the outcomes are based on a sector of space forming infinite and finite aleph structures fused with differentiated decoupled shapes. A big knot of 5 point connections if you go looking hard enough, explicitly or implicitly. This isn't news, and somehow the model behaved as though this structure is in fact some sort of news. The codebooks are built on functional math specifically because that's how we debugged them. Fable spent 3 days figuring out what we already knew.

Upcoming behavioral assessments include a large array of QWEN VLM models I will publish benchmarks for.

These will be aligned to generic use-case, meaning as many tasks as possible that do not require finetuning.

• Which produces valid json schema?
• image classification
• bounding box location
• image text identification and accuracy checking
• structural and spatial awareness
• 3d geometric object identification and awareness
• camera rotational offset
• subject fixation and awareness
• semantic association
• depth analysis
• segmentation potential
• vit accuracy to image prompting
• outline and association testing
• style identification and structural awareness
• type differentiation with data types; json, yaml, MD, and a multitude of other potentials.
• utilization and response to those types and the expected prompts

geolip-aleph-void and the LM aleph routing is implicit recursive infinities confined into a microcosm of forced rebounding finite space forced through a gelu sift - more akin to an emulated quaternion. All because quaternion is computationally heavy and Cantor's fractals are additionally computationally precise (often >fp64 required), requiring an entirely deviant approach to rotary in order to computationally stabilize the system at BF16 so it won't take 2 weeks for a single epoch on a model 35m params.

Makes me feel a little overdressed for the occasion.

Currently am upscaling everything in my big diffusion pretrain dataset to start training some real structure.
If a couple epochs of that data doesn't activate the model, I'll need to employ a David structure and attempt to teach global attention to a shared battery set.

Simultaneously heavy experimentation on the geolip-aleph-void structure and potential offshoot objectives are being transcribed and curated. There are multiple prototypes based on functional known structures that have potential and among the discoveries today include a stable attention mechanism that can be curated further. This is based off an earlier experiment named cantor fractal routing.

https://github.com/AbstractEyes/geofractal/blob/main/src/geofractal/model/layers/attention/cantor_multiheaded_fusion_fp64_v2.py

This system was a badly optimized prototype that managed to stabilize deep-complexity fractal routes with low vram at the cost of time. Primary problem with it, was the time only matters if you're training a massive model. You don't get benefit from small models like how I usually train, so it was mothballed.

The geolip aleph routed attention is a viable option to train a david and it can in fact handle small models but needs much testing. As it stands it does not benefit from the same large model routing optimizations for vram as the cantor fractal routing. This essentially means that it will OOM like traditional attention. However, because it's based on the aleph structure it'll stabilize point clouds for Q and K, which when employed structurally can provide a cached V. I'm testing structural changes that will allow the structure to bind deterministic systems to K so KV caching can happen and Q can operate normally.

With the aleph routed attention worked out I'll be able to provide an actual backbone to SDXL instead of just a partial one through tokens. This will allow the model to directly differentiate tokens through gated learning and attention anchoring, which in theory could enable surge training through procrustes. They are essentially different towers though, so I'm uncertain still if the effect will transcribe or be topical until after the experiments.

Massive expansion to optimization happening today. I can't spend all these upcoming days training when optimization can happen now. My target today is to have a marked and improved speed, as well as enabling accelerate training for upcoming heavy runpod expansion. Likely switching to 8 a40s to train will be a more reasonable use of cost and effectiveness of training.

I advise whenever using qwen 3.5 to install fast path linear attention.

The 9 experiment sweep is currently running on the first conversion from SDXL epsilon prediction to SDXL ODE flow matching.

Using the same formula as was used to train SD15-Flow-Lune, the predictions match identically and the format will be directly relational to the results as if SDXL was never touched by David.

The tests yesterday show that I needed independent tests, so I began testing a 9 configuration sweep. With that the trainer for the sweep was uploaded to the repo as well.

https://huggingface.co/AbstractPhil/geolip-sdxl-aleph

This experiment will prove without a doubt if the alephs help in direct tokenization distillation in the small size, or if they help in a higher-fidelity scale as I've just prepared a new variant of geolip-aleph-transformer to specifically scale them up in a similar multiscale lensed upscale fashion as David provides.

These conclusions will arrive together by this afternoon, and this decides which configuration is best to convert SDXL. The base is already done, which is running baseline clip_l and baseline clip_g with no alephs. The results aren't promising compared to the results yesterday, which showed explicit results by epoch 2, while the tests today show invalid results by epoch 100 without the alephs.

As it stands the alephs are eons ahead, but the results today will determine the route.

With the first major experiment I release the notebooks. The massive amounts of information and pure empirical data accumulated to determine what alephs are, why they exist, how they help, how they hinder, and how I defeated all of the weaknesses over time through pure mathematics, determination, heavy-handed failures, minor successes, and an absolute ton of analysis.

I could have never done all of this in a lifetime without Claude.

https://huggingface.co/AbstractPhil/geolip-hypersphere-experiments/tree/main/aleph

I have rebuilt the SVAE into the core formula.

It is now a direct representation of the spherical aleph-void behavior, replicating more purely the directions achieved by the SVAE with a direct utilizable codebook and a pure access to cosine-similarity trained clean into the system.

With this the params dropped a large portion, and the model is to be renamed;

geolip-aleph-void

With this model's discovery and emergence, the SVAE experiment line is pushed to the aleph-void variant.

The SVAE batteries and model will continue to be supported and additional tests will be performed in the immediate and distant future on the model to improve the transformer with the upcoming behavior and math earned through training this new model. The weights and system of the SVAE will continue to be directly supported.

The SVAE itself is a FANTASTIC research tool. It can be fed many many elements and analyzed, the results utilized empirically and usefully. There are no limits to the model's utility in research, and utility in pragmatic use-case when hooked to models directly, in use for compression, and in use for generation - all because the model's format WILL converge the recon if the data is fed within the space as per the 1000+ tests show.

The geolip-aleph-void will represent the natural evolution of this model into the block-useful state. The construction and utility of this model will be directly aligned to a high complexity multi-scalar storage, entirely dependent on emergent aleph behavior in conjunction with a void-driven codebook inference. The combined behavior provides a multi-tiered high complexity geometric feature that will be utilized in upcoming distillations from large pretrained models into highly compressed atomic-sized models.

The two models share the encoder structure, and multiple elements, so they can be directly compared. No apples to oranges, direct comparison. They are siblings, and belong together.

The true power of the aleph stems from the decoder process. The representational utilization is deviant on many spectrums, and the process allows for robust representational utilization of the encoder structure with the capacity to recon if necessary.

massive grin
That is a perfect convergence.
Now... lets see what happens when we snap a microcosm-sized battery, to a macrocosm shape. All the way up to d256.

It begins. The light is scaled to parity.

The transformer is much cleaner now. The scaling rule is no longer just a rule, it can be considered an IO scaling guarantee based on the input and output formats tested with the SVAE lens.

Larger lens can handle the canon variation, which preserves a different format of structure than the signed variation. They are both macrostructural representations of the same internal shape, one contains negations one contains perfectly constrained space.

The first of the two will be uploaded momentarily.

==========================================================================================
[sign-test] lens_sign='canon'
==========================================================================================
geolip-svae-v2 TWO-RECON | battery(PatchSVAE) 52,131 + shell 6,309,900 (shell 121x the microcosm) + growth 0 | D_base4->D_lens256 V32 ps2 | cuda
  battery -> INTERNAL recon (pure MSE) | shell -> EXTERNAL recon (detached stem, lens_sign=canon) | adam lr=0.001 wd=0 sched=onecycle
  growth : parked (no stencil)
  [ByteTrigramDataset] Loading corpus wikitext-2-raw-v1...
  [ByteTrigramDataset] Corpus: 10,938,611 bytes (10.9 MB), 768 bytes/image, 14,242 non-overlapping images available (10,937,843 valid window starts)
  epoch  0: int[mse=0.01549 rec=12.93%] ext[mse=0.01293 rec=11.45%] | cc=-1.49 rig=0.0000 a=0.024 env=True
  epoch  1: int[mse=0.00053 rec=30.25%] ext[mse=0.00063 rec=27.02%] | cc=-1.48 rig=0.0000 a=0.024 env=True
  epoch  2: int[mse=0.00013 rec=48.89%] ext[mse=0.00020 rec=27.76%] | cc=-1.47 rig=0.0000 a=0.024 env=True
  epoch  3: int[mse=0.00007 rec=41.68%] ext[mse=0.00014 rec=33.32%] | cc=-1.47 rig=0.0000 a=0.025 env=True
  epoch  4: int[mse=0.00008 rec=50.93%] ext[mse=0.00013 rec=43.52%] | cc=-1.46 rig=0.0000 a=0.024 env=True
  epoch  5: int[mse=0.00009 rec=68.53%] ext[mse=0.00015 rec=53.88%] | cc=-1.46 rig=0.0000 a=0.024 env=True
  epoch  6: int[mse=0.00009 rec=70.30%] ext[mse=0.00015 rec=55.59%] | cc=-1.46 rig=0.0000 a=0.024 env=True
  epoch  7: int[mse=0.00009 rec=14.55%] ext[mse=0.00014 rec=15.87%] | cc=-1.46 rig=0.0000 a=0.025 env=True
  epoch  8: int[mse=0.00008 rec=70.50%] ext[mse=0.00013 rec=59.38%] | cc=-1.46 rig=0.0000 a=0.025 env=True
  epoch  9: int[mse=0.00008 rec=40.62%] ext[mse=0.00012 rec=34.12%] | cc=-1.46 rig=0.0000 a=0.025 env=True
  epoch 10: int[mse=0.00007 rec=40.38%] ext[mse=0.00010 rec=42.45%] | cc=-1.46 rig=0.0000 a=0.025 env=True
  epoch 11: int[mse=0.00006 rec=56.09%] ext[mse=0.00008 rec=49.56%] | cc=-1.46 rig=0.0000 a=0.025 env=True
  epoch 12: int[mse=0.00005 rec=30.38%] ext[mse=0.01204 rec=23.14%] | cc=-1.46 rig=0.0000 a=0.025 env=True
  epoch 13: int[mse=0.00004 rec=58.75%] ext[mse=0.00019 rec=35.80%] | cc=-1.46 rig=0.0000 a=0.025 env=True
  epoch 14: int[mse=0.00004 rec=64.02%] ext[mse=0.00014 rec=40.96%] | cc=-1.46 rig=0.0000 a=0.025 env=True
  epoch 15: int[mse=0.00003 rec=51.41%] ext[mse=0.00012 rec=32.35%] | cc=-1.46 rig=0.0000 a=0.025 env=True
  epoch 16: int[mse=0.00003 rec=54.11%] ext[mse=0.00010 rec=36.09%] | cc=-1.46 rig=0.0000 a=0.025 env=True
  epoch 17: int[mse=0.00002 rec=53.60%] ext[mse=0.00008 rec=39.52%] | cc=-1.46 rig=0.0000 a=0.025 env=True
  epoch 18: int[mse=0.00002 rec=40.67%] ext[mse=0.00006 rec=28.57%] | cc=-1.46 rig=0.0000 a=0.025 env=True
  epoch 19: int[mse=0.00002 rec=84.62%] ext[mse=0.00005 rec=63.56%] | cc=-1.46 rig=0.0000 a=0.025 env=True
  epoch 20: int[mse=0.00001 rec=83.90%] ext[mse=0.00004 rec=64.16%] | cc=-1.46 rig=0.0000 a=0.025 env=True
  epoch 21: int[mse=0.00001 rec=88.53%] ext[mse=0.00003 rec=71.30%] | cc=-1.45 rig=0.0000 a=0.025 env=True
  epoch 22: int[mse=0.00001 rec=67.54%] ext[mse=0.00002 rec=44.91%] | cc=-1.45 rig=0.0000 a=0.025 env=True
  epoch 23: int[mse=0.00001 rec=95.63%] ext[mse=0.00002 rec=83.82%] | cc=-1.45 rig=0.0000 a=0.025 env=True
  epoch 24: int[mse=0.00001 rec=98.24%] ext[mse=0.00001 rec=91.46%] | cc=-1.44 rig=0.0000 a=0.025 env=True
  epoch 25: int[mse=0.00000 rec=97.58%] ext[mse=0.00001 rec=91.81%] | cc=-1.44 rig=0.0000 a=0.025 env=True
  epoch 26: int[mse=0.00000 rec=96.54%] ext[mse=0.00001 rec=87.23%] | cc=-1.43 rig=0.0000 a=0.025 env=True
  epoch 27: int[mse=0.00000 rec=99.11%] ext[mse=0.00001 rec=95.73%] | cc=-1.43 rig=0.0000 a=0.025 env=True
  epoch 28: int[mse=0.00000 rec=98.92%] ext[mse=0.00000 rec=94.47%] | cc=-1.42 rig=0.0000 a=0.025 env=True
  epoch 29: int[mse=0.00000 rec=99.44%] ext[mse=0.00000 rec=98.19%] | cc=-1.42 rig=0.0000 a=0.025 env=True
  epoch 30: int[mse=0.00000 rec=99.49%] ext[mse=0.00000 rec=98.55%] | cc=-1.41 rig=0.0000 a=0.025 env=True
  epoch 31: int[mse=0.00000 rec=99.56%] ext[mse=0.00000 rec=98.76%] | cc=-1.41 rig=0.0000 a=0.025 env=True
  epoch 32: int[mse=0.00000 rec=99.61%] ext[mse=0.00000 rec=99.03%] | cc=-1.40 rig=0.0000 a=0.025 env=True
  epoch 33: int[mse=0.00000 rec=99.65%] ext[mse=0.00000 rec=99.19%] | cc=-1.40 rig=0.0000 a=0.025 env=True
  epoch 34: int[mse=0.00000 rec=99.67%] ext[mse=0.00000 rec=99.29%] | cc=-1.40 rig=0.0000 a=0.025 env=True
  epoch 35: int[mse=0.00000 rec=99.70%] ext[mse=0.00000 rec=99.35%] | cc=-1.39 rig=0.0000 a=0.025 env=True
  epoch 36: int[mse=0.00000 rec=99.71%] ext[mse=0.00000 rec=99.39%] | cc=-1.39 rig=0.0000 a=0.025 env=True
  epoch 37: int[mse=0.00000 rec=99.72%] ext[mse=0.00000 rec=99.41%] | cc=-1.39 rig=0.0000 a=0.025 env=True
  epoch 38: int[mse=0.00000 rec=99.72%] ext[mse=0.00000 rec=99.42%] | cc=-1.39 rig=0.0000 a=0.025 env=True
  epoch 39: int[mse=0.00000 rec=99.72%] ext[mse=0.00000 rec=99.43%] | cc=-1.39 rig=0.0000 a=0.025 env=True
  best recovery — internal 99.72% | external 99.43% | ckpt sign_test_canon/sign_canon.pt

==========================================================================================
[sign-test] lens_sign='signed'
==========================================================================================
geolip-svae-v2 TWO-RECON | battery(PatchSVAE) 52,131 + shell 6,309,900 (shell 121x the microcosm) + growth 0 | D_base4->D_lens256 V32 ps2 | cuda
  battery -> INTERNAL recon (pure MSE) | shell -> EXTERNAL recon (detached stem, lens_sign=signed) | adam lr=0.001 wd=0 sched=onecycle
  growth : parked (no stencil)
  [ByteTrigramDataset] Loading corpus wikitext-2-raw-v1...
  [ByteTrigramDataset] Corpus: 10,938,611 bytes (10.9 MB), 768 bytes/image, 14,242 non-overlapping images available (10,937,843 valid window starts)
  epoch  0: int[mse=0.01550 rec=12.86%] ext[mse=0.00944 rec=16.90%] | cc=-1.49 rig=0.0000 a=0.024 env=True
  epoch  1: int[mse=0.00052 rec=30.22%] ext[mse=0.00028 rec=37.08%] | cc=-1.48 rig=0.0000 a=0.024 env=True
  epoch  2: int[mse=0.00013 rec=48.07%] ext[mse=0.00009 rec=36.29%] | cc=-1.47 rig=0.0000 a=0.024 env=True
  epoch  3: int[mse=0.00008 rec=56.08%] ext[mse=0.00008 rec=54.79%] | cc=-1.47 rig=0.0000 a=0.024 env=True
  epoch  4: int[mse=0.00008 rec=47.01%] ext[mse=0.00009 rec=38.59%] | cc=-1.46 rig=0.0000 a=0.024 env=True
  epoch  5: int[mse=0.00009 rec=64.35%] ext[mse=0.00010 rec=61.49%] | cc=-1.46 rig=0.0000 a=0.024 env=True
  epoch  6: int[mse=0.00009 rec=57.33%] ext[mse=0.00010 rec=55.95%] | cc=-1.46 rig=0.0000 a=0.024 env=True
  epoch  7: int[mse=0.00009 rec=25.34%] ext[mse=0.00009 rec=17.40%] | cc=-1.46 rig=0.0000 a=0.024 env=True
  epoch  8: int[mse=0.00009 rec=27.43%] ext[mse=0.00008 rec=28.23%] | cc=-1.46 rig=0.0000 a=0.024 env=True
  epoch  9: int[mse=0.00008 rec=72.23%] ext[mse=0.00007 rec=76.08%] | cc=-1.46 rig=0.0000 a=0.024 env=True
  epoch 10: int[mse=0.00007 rec=15.55%] ext[mse=0.00006 rec=19.54%] | cc=-1.46 rig=0.0000 a=0.024 env=True
  epoch 11: int[mse=0.00006 rec=60.12%] ext[mse=0.00005 rec=62.56%] | cc=-1.46 rig=0.0000 a=0.024 env=True
  epoch 12: int[mse=0.00005 rec=59.56%] ext[mse=0.00005 rec=60.09%] | cc=-1.46 rig=0.0000 a=0.024 env=True
  epoch 13: int[mse=0.00004 rec=44.68%] ext[mse=0.01709 rec=23.43%] | cc=-1.46 rig=0.0000 a=0.025 env=True
  epoch 14: int[mse=0.00004 rec=66.30%] ext[mse=0.00010 rec=53.38%] | cc=-1.46 rig=0.0000 a=0.025 env=True
  epoch 15: int[mse=0.00003 rec=27.36%] ext[mse=0.00005 rec=34.04%] | cc=-1.46 rig=0.0000 a=0.025 env=True
  epoch 16: int[mse=0.00003 rec=52.60%] ext[mse=0.00004 rec=43.46%] | cc=-1.46 rig=0.0000 a=0.026 env=True
  epoch 17: int[mse=0.00002 rec=76.24%] ext[mse=0.00004 rec=66.86%] | cc=-1.46 rig=0.0000 a=0.026 env=True
  epoch 18: int[mse=0.00002 rec=55.56%] ext[mse=0.00003 rec=45.13%] | cc=-1.46 rig=0.0000 a=0.026 env=True
  epoch 19: int[mse=0.00002 rec=86.47%] ext[mse=0.00003 rec=76.29%] | cc=-1.46 rig=0.0000 a=0.026 env=True
  epoch 20: int[mse=0.00001 rec=69.85%] ext[mse=0.00002 rec=60.43%] | cc=-1.46 rig=0.0000 a=0.026 env=True
  epoch 21: int[mse=0.00001 rec=64.09%] ext[mse=0.00002 rec=52.68%] | cc=-1.45 rig=0.0000 a=0.026 env=True
  epoch 22: int[mse=0.00001 rec=87.53%] ext[mse=0.00001 rec=77.76%] | cc=-1.45 rig=0.0000 a=0.026 env=True
  epoch 23: int[mse=0.00001 rec=86.32%] ext[mse=0.00001 rec=80.48%] | cc=-1.45 rig=0.0000 a=0.026 env=True
  epoch 24: int[mse=0.00001 rec=90.38%] ext[mse=0.00001 rec=83.52%] | cc=-1.44 rig=0.0000 a=0.026 env=True
  epoch 25: int[mse=0.00000 rec=91.73%] ext[mse=0.00001 rec=82.42%] | cc=-1.44 rig=0.0000 a=0.026 env=True
  epoch 26: int[mse=0.00000 rec=99.00%] ext[mse=0.00001 rec=98.25%] | cc=-1.43 rig=0.0000 a=0.027 env=True
  epoch 27: int[mse=0.00000 rec=98.97%] ext[mse=0.00000 rec=97.66%] | cc=-1.43 rig=0.0000 a=0.027 env=True
  epoch 28: int[mse=0.00000 rec=99.38%] ext[mse=0.00000 rec=98.97%] | cc=-1.42 rig=0.0000 a=0.027 env=True
  epoch 29: int[mse=0.00000 rec=99.47%] ext[mse=0.00000 rec=99.26%] | cc=-1.42 rig=0.0000 a=0.027 env=True
  epoch 30: int[mse=0.00000 rec=99.54%] ext[mse=0.00000 rec=99.35%] | cc=-1.41 rig=0.0000 a=0.027 env=True
  epoch 31: int[mse=0.00000 rec=99.59%] ext[mse=0.00000 rec=99.44%] | cc=-1.41 rig=0.0000 a=0.027 env=True
  epoch 32: int[mse=0.00000 rec=99.63%] ext[mse=0.00000 rec=99.53%] | cc=-1.40 rig=0.0000 a=0.027 env=True
  epoch 33: int[mse=0.00000 rec=99.66%] ext[mse=0.00000 rec=99.58%] | cc=-1.40 rig=0.0000 a=0.027 env=True
  epoch 34: int[mse=0.00000 rec=99.69%] ext[mse=0.00000 rec=99.61%] | cc=-1.40 rig=0.0000 a=0.027 env=True
  epoch 35: int[mse=0.00000 rec=99.71%] ext[mse=0.00000 rec=99.63%] | cc=-1.40 rig=0.0000 a=0.027 env=True
  epoch 36: int[mse=0.00000 rec=99.73%] ext[mse=0.00000 rec=99.65%] | cc=-1.39 rig=0.0000 a=0.027 env=True
  epoch 37: int[mse=0.00000 rec=99.73%] ext[mse=0.00000 rec=99.67%] | cc=-1.39 rig=0.0000 a=0.027 env=True
  epoch 38: int[mse=0.00000 rec=99.74%] ext[mse=0.00000 rec=99.67%] | cc=-1.39 rig=0.0000 a=0.027 env=True
  epoch 39: int[mse=0.00000 rec=99.74%] ext[mse=0.00000 rec=99.67%] | cc=-1.39 rig=0.0000 a=0.027 env=True
  best recovery — internal 99.74% | external 99.67% | ckpt sign_test_signed/sign_signed.pt

================================================================
  SIGN TEST — best recovery (internal / external)
================================================================
    lens_sign=canon    internal=99.72%  external=99.43%
    lens_sign=signed   internal=99.74%  external=99.67%