AbstractPhil/geolip-svae-h2-64

Battery array inference update

As per the ablation sweeps in https://huggingface.co/AbstractPhil/geolip-svae-implicit-solver-experiments I have established a new methodology for inferencing geometric pointwise behavior from the geolip batteries.

!pip uninstall geolip-svae geofractal geolip-core geometricvocab wide_compiler -y
!pip install "git+https://github.com/AbstractEyes/geolip-svae.git"

Ensure you have the geolip package installed with the subpackages for a smooth transition to the new model format.

from transformers import AutoModel
from geolip_svae.arrays import BatteryArrayModel  # registered class

model = AutoModel.from_pretrained("AbstractPhil/geolip-svae-h2-64")

# Same images-in pattern as model.forward()
codebook = model.compute_axis_codebook(0, 'final', calib_images)
activations = model.encode_axes(test_images, 0, 'final', codebook)
codes = model.quantize_axes(test_images, 0, 'final', codebook)

# Or you can compute the entire codebook at once using a series of targets.
targets = [(0, 'final'), (1, 'final'), (2, 'final')]
codebooks = model.compute_axis_codebooks(targets, gaussian_calib)
# returns {(0,'final'): tensor, (1,'final'): tensor, (2,'final'): tensor}

Resolution independent structural

Just like the larger models.

MSE translates. Structures scale. It's omega.

Tomorrow I prove hot swapping capacity.

Omega MSE battery array first test

Success.

The batteries did retain the necessary information to utilize the MSE accuracy downstream.

With a small projective MSE to compact the opinions with a shallow MLP, the model simply finds the right reconstruction pathway within nearly zero time.

Tests WITHOUT the reconstruction pathway capped at around 48%, earlier attempts with pure weighted bias ended up random chance.

Simple MLP had no problems.

Some of the noise types did suffer a little. However, the final result shows the true outcome.

The omega solvers DID solve the task.

The experiment was highly successful, the omega array works for this particular process.

First steps first faults

By design I chose multiple combinations with gaussian to arbitrate the differentiation and those gaussian solvers are proving to be less usefully incorrect than I had anticipated. I will need to strategize a battery refactor after this first wave of experiments are completed.

I'm thinking dual noise combinations specializing on no single noise type in conjunction with negative-biased single noisers and single-biased single noisers.

That should cut through about any classification need for standard noise just by sampling MSE.

This is pretty much now a practice of how to select them, because they have all the data, and the battery array will be more accurate when the batteries are curated and selected correctly.

The more batteries, the stronger this experimental solver will be and the more robust data will be received from the differentiation analysis.

H2-64: first sphere-solver battery array (HIGH band)

64 independently-trained H2_linear_matched sphere-solver batteries bundled as a single HuggingFace AutoModel. Each battery is a minimal patch-SVAE variant (~57K parameters) trained at the HIGH band of the omega-token architecture (D=4, V=32, patch_size=4, hidden=64, 64×64 images). Three training checkpoints per battery (epoch_1, best, final) are packaged together, giving 192 total banks. The model exposes a per-bank MSE signature that can be used for ensembling, signature-based classification, and OOD detection.

Architecture

Each battery is a PatchSVAE configured as the H2 sphere-solver variant: sphere-normalized rows of an internal matrix M, followed by a learned linear readout (not SVD — the linear_readout=True, svd_mode='none' ablation path), followed by spectral cross-attention, followed by a small MLP decoder and zero-initialized boundary smoothing. All 64 batteries share identical architecture; only the training noise composition differs across them.

Property	Value
Battery class	geolip_svae.model.PatchSVAE
Ablation kwargs	svd_mode='none', linear_readout=True, match_params=True, smooth_mid=16
Image size	64×64
Patch size	4×4 (→ 256 patches per image)
D (spectral dim)	4
V (matrix rows)	32
Hidden	64
Depth	1 residual block
Cross-attention layers	1
Parameters per battery	57,215
Epoch phases bundled	3 (epoch_1, best, final)
Total banks	192
Total parameters	10,985,280

Usage

geolip-svae handles the auto-registration — no trust_remote_code needed.

pip install git+https://github.com/AbstractEyes/geolip-svae.git

from transformers import AutoModel
import torch

model = AutoModel.from_pretrained("AbstractPhil/geolip-svae-h2-64")
images = torch.randn(4, 3, 64, 64)

signature = model(images)
# shape: [batch, n_batteries, n_epoch_phases]  →  [4, 64, 3]
# signature[b, i, k] = MSE of image b reconstructed by battery i at phase k

Access a specific battery:

battery = model.bank(battery_idx=0, phase="best")   # single PatchSVAE
out = battery(images)
# out['recon']:          reconstructed images
# out['svd']['M']:       sphere-normed encoded matrix
# out['svd']['S']:       cross-attention-coordinated singular-value surrogate

Per-battery metadata (noise composition, MSE at each phase, epoch numbers) lives in model.config.batteries.

Training composition

Each battery was trained on a specific composition of 16 noise types. The array is organized as four subgroups of 16:

1. Single-noise experts (16) — one battery per noise type, each is an expert on its one type.
2. Gaussian + one (16) — 15 batteries trained on gaussian paired with one other noise type, plus 1 battery trained on all 16 noise types as a generalist.
3. Gaussian quads (16) — each battery trained on gaussian + one easy + one medium + one hard noise type, balanced covering design so each noise appears in multiple quads.
4. No-gaussian quads (16) — each battery trained on (easy, medium, hard, hard) with no gaussian exposure — engineered gaussian blind spots, useful as anchor points for signature-based classification.

Training: 10 epochs, 1M samples/epoch, batch size 256, seed 42, pure Adam. See geolip_svae.arrays.specs.h2_64 in the source repo for the deterministic covering designs that selected which noise combinations went to which battery.

Epoch phases in the signature

The second axis of the signature tensor indexes the three packaged checkpoints:

Index	Phase	Description
0	epoch_1	After 1 epoch of training — the "early" reconstruction fingerprint
1	best	The epoch that achieved lowest test MSE across the 10-epoch run
2	final	Epoch 10 (or whichever was last) — the "settled" fingerprint

When a battery's best epoch equals its first or final, the corresponding bank is populated with the same weights (no dedup at inference; dedup is only at build-time download). The three phases exist because training-trajectory information is itself a discriminator — a battery's epoch-1 reconstruction is a different function than its epoch-10 reconstruction, and both are useful signals.

Empirical results

The array has been tested across single-noise, compositional, and large-resolution classification tasks. Selected headline numbers:

Task	Setup	Accuracy	Random baseline
16-way single-noise	16 single-noise expert MSEs + small MLP on 64×64	92.7%	6.3%
16-way single-noise	All 64 batteries + small MLP on 64×64	93.2%	6.3%
20-way noise-pair (compositional)	64 batteries + MLP, quadrant-mixed 64×64	88.3%	5.0%
16-way single-noise	1 battery (all_16 generalist) + nearest-centroid at 1024×1024 via tile-scan	78.9%	6.3%
19-way noise + zone-matte	18-battery subset + summary-stats MLP at 1024×1024 via tile-scan	95.8%	5.3%

Three findings worth calling out:

Resolution invariance of the scan statistic. Individual batteries were trained exclusively at 64×64, but their per-tile reconstruction MSE — measured by breaking a large image into non-overlapping 64×64 tiles and forwarding each through the battery — is identical to five decimal places at 256×256, 512×512, and 1024×1024. The tile-MSE distribution is a property of the noise distribution, not the image. This makes any h2-64 battery directly usable as a large-image scanner via tiling.

A curated 18-battery subset is the production architecture. 16 single-noise experts plus the two gaussian-paired colored-spectrum batteries (pair_04_pink, pair_05_brown) total ~1M parameters — 10× smaller than the full 192-bank array — and outperform it on the harder task of compositional classification at 1024×1024. This includes 100% accuracy on pink and brown samples at 1024, resolving a confusion present at 64×64 and 256×256. The multi-noise batteries beyond those two pairs contribute little additional classification signal for these tasks.

One systemic limitation: poisson. Poisson reconstruction MSE varies widely tile-to-tile on a single input image because the training generator drew a random λ ∈ [0.5, 20] per sample. Classifiers see a wide scan distribution that overlaps with other low-MSE noises. Poisson accuracy oscillates between 50% and 100% across resolutions. Not a defect of the array — it's the training distribution being intentionally broad.

The overall result is that the array's signature is discriminative and resolution-scalable, but most of that signal lives in a small subset of the batteries. The array's original design (four 16-battery subgroups of single/pair/quad/no-gaussian-quad) provided combinatorial coverage; the empirical utility concentrates in the single-noise experts plus a few pair disambiguators. Future arrays may be smaller and more targeted.

Source

• Package: github.com/AbstractEyes/geolip-svae
• Training artifacts: the per-battery checkpoints, TB logs, and final reports are also in this repo under {subgroup}/{variant}/ paths, alongside the assembled model.safetensors.
• Related: geolip-core (FLEigh eigendecomposition, required dependency)

---

Dev log

4/22/2026 — Evening: methodology validated, radar works

Ran a series of experiments to actually use this array as a discriminator.

First finding: trying to hand-design a weighted classifier from z-scores of the MSE signature kept collapsing to degenerate predictions. Two different z-score directions both failed. What worked was giving up on hand-weighting and just training a tiny MLP on the 64-dim signature — converged to 92.7% in one epoch. The signal was almost linearly separable from the start. My hand-designed decoders were destroying it.

Tested larger resolutions next. Individual batteries tile-scan beautifully — feed a 1024×1024 image, slice it into 256 tiles of 64×64, push each tile through ONE battery, collect per-tile MSE. The mean tile MSE at 1024 is identical to the mean at 256 to five decimal places. The tiny batteries are genuinely resolution-scalable through piecemeal tiling. No retraining, no fine-tuning, no cross-tile communication needed.

Final architecture test: batch 18 batteries (16 single-noise experts + the pink/brown gaussian-pairs) and tile-scan compositional inputs with zone-matte layouts. 95.8% accuracy on 19-way classification at 1024×1024 with 1M params. That beats the full 11M-param array at its native 64×64 task.

Pink/brown turned out not to be the structural collision I thought it was — just needed more tile samples and the pair-disambiguators in the scan subset. At 1024 they're 100% both.

Poisson remains confused because the training generator used random λ across [0.5, 20] per sample, so different tiles from one poisson image look like they have different rates. Not fixable from the array side — it's a training-distribution artifact.

The radar framing is the right one. Small batteries, scan multiple times, build signatures from tile statistics. Moving the single-battery piecemeal utilities and the subset-scanner into the package proper next.

4/22/2026 — Hard at work

Today's plan

Fuse the battery array into a single collection pt + safetensors and include automodel for ease-of-access to the collective. This is the first HIGH frequency array.

Simple starts

We'll be running a series of noise analysis first on the array, figuring out which know which noises, which noises they know best, which noises they are worst at, and so on. This will give us a weighted marginal benchmark for the array and a first test use-case potential. These will always respond these ways to noise and the tests will be quite robust to guarantee the system either KNOWS the noise, or is simply reconstructing everything unilaterally informative. Cross your fingers they didn't become perfect solvers, and instead left some knowledge gaps. That was the plan.

Batched implementation next

If the plan works and the models deviate, batched information is next.

Faulty battery replacement plans

Each battery that happens to be faulty can be snapped out and replaced with a different battery that fits the frequency. For now the experiment is staying uniformly aligned, but this will branch out. Currently there are too many potentials to see this linearly, it must be branched outward.

Musing

The ironic naming of the H2 branding isn't lost on me. It has compelled me to look directly into chemistry elemental research and relational understanding between atomic structures as a side-project. Hydrogen... Maybe. Just maybe.

4/21/2026 — First plan

The home of the first 64 noise array of omega solver mini batteries. Each battery is specifically meant to have a different opinion of the overall structure and will be trained with a series of configurations.

• 16 batteries with one different type of noise trained each, each one an expert of their own noise, each of the 16 given one of the 16 noise types from the array. This is 1 expert per noise type.
• 16 double noise trained, gaussian + additional , which means every one of them has gaussian + one other type of noise, we can eliminate the one that would have two gaussians and simply train one with all 16 types of noise
• 16 quad noise trained, 4 each - gaussian + 1 easy + 1 medium diff + 1 hard diff each
• 16 no gaussian quads, where each don't know what gaussian is and they learn 4 different types of noise in the list, ensuring none of them learn the exact same noise types

Total batteries: 64 miniature noise solvers, approximately 3.2m params. 64 nth resolution independent solvers should be enough to handle the upcoming task.