Datasets:
Eve's Embrace of Extreme Quantization v1.0 — runtime quickstart
The release provides finite quantizer and correction sources, strict paid decoders, tests, scientific receipts, and public synthetic demonstrations. The original pretrained model, model-derived checkpoint payloads, text tokens, activation caches and optimizer states are not redistributed. Rebuilding the real-model experiment requires the separately obtained model and calibration data identified in its protocols. The supplied 4,590-byte bundle contains constructed zero base weights and finite example overlays; its compression is a format demonstration and establishes no neural quality or industry compression advantage.
Install and verify
From the extracted project root, install the core dependencies and run the focused checks:
python -m pip install -r requirements.txt
python -m unittest tests.test_v1_reservoir_codec tests.test_v1_bundle_codec tests.test_v1_bundle_operator
python examples/generate_v1_codec_demo.py
The focused codec/operator receipt records 33 passing tests. The generator
recreates examples/v1_sparse_demo.eer, examples/v1_lowrank_demo.eel, the
complete synthetic examples/v1_bundle_demo.eeb1, and its input, resident
bias and expected reference output arrays. examples/v1_codec_demo.json
contains exact paid costs, hashes and every lossless catalogue trial. The
generator and these checks download nothing and run no neural forward pass.
Inspect self-describing bytes
python v1_runtime.py inspect examples/v1_sparse_demo.eer
python v1_runtime.py inspect examples/v1_lowrank_demo.eel
python v1_runtime.py inspect examples/v1_bundle_demo.eeb1 --resident-bias examples/v1_bundle_demo_bias.npy
Inspection validates checksums, canonical metadata, sorted IDs, finite words,
sizes and every embedded projection identity. Bundle inspection uses
decode_matrices=False and does not construct complete floating projection
matrices. The original resident fc2 bias is supplied separately. A paid bias
overlay requires the resident array to be finite FP32 of length 768 and to
match the hash inside the paid bundle before installation.
The public bundle's exact cost is:
| Component | Bytes |
|---|---|
| Header | 64 |
| Canonical self-describing directory and contract | 1,539 |
| Six complete EEFC/EEV6 base projection frames | 2,577 |
| EERV weight correction | 193 |
| EERV intercept correction | 185 |
| SHA256 trailer | 32 |
| Complete bundle | 4,590 |
The separately retained resident bias adds 3,072 FP32 bytes. A real-model logical checkpoint must also count every other unchanged parameter. Bundle bytes alone are therefore not whole-model storage or deployment memory.
Apply the CPU reference operator
python v1_runtime.py apply examples/v1_bundle_demo.eeb1 --input examples/v1_bundle_demo_input.npy --output demo_output.npy --resident-bias examples/v1_bundle_demo_bias.npy --include-bias
The default projection is the full name
model.decoder.layers.0.fc2. --projection selects one of the other five
paid full projection names. Only fc2 can include the explicitly supplied
resident bias through this CLI. The example output has shape (1, 768) and
every entry equals 0.125. Compare it against the supplied reference:
python -c "import numpy as np; np.testing.assert_array_equal(np.load('demo_output.npy', allow_pickle=False), np.load('examples/v1_bundle_demo_output.npy', allow_pickle=False)); print('PASS')"
Standalone EER1/EERV and EEL1/EELV apply actions compute the uninstalled
correction in FP64. They do not add an original model weight or bias. The
complete EEB1 operator computes the FP64 action of its native-installed
FP32 weight values and optionally its installed fc2 bias.
Eleven lossless choices, with measured complete costs
Every finite correction has the raw original frame as the size incumbent. The ten wrappers combine five reversible uint16-word views with zlib level 9 or XZ preset 6. Metadata, headers, IDs and checksums all remain paid. The following costs are reproduced in the public demo receipt:
| Choice | Tiny sparse sidecar | Bundle weight sidecar | Bundle bias sidecar |
|---|---|---|---|
| Original raw frame | 155 | 3,174 | 1,636 |
| Raw words + zlib9 | 227 | 193 | 185 |
| Raw words + xz6 | 275 | 258 | 244 |
| Byte planes + zlib9 | 223 | 193 | 186 |
| Byte planes + xz6 | 275 | 254 | 244 |
| XOR + byte planes + zlib9 | 223 | 195 | 187 |
| XOR + byte planes + xz6 | 275 | 258 | 248 |
| First differences + byte planes + zlib9 | 223 | 195 | 187 |
| First differences + byte planes + xz6 | 275 | 258 | 248 |
| Second differences + byte planes + zlib9 | 224 | 198 | 188 |
| Second differences + byte planes + xz6 | 275 | 258 | 248 |
Strictly shorter candidates replace the incumbent; ties keep the earlier catalogue choice. The tiny raw sidecar beats every compressed wrapper because framing dominates. The repetitive synthetic bundle corrections benefit from zlib. These examples explain the byte policy; they do not predict rates of learned neural parameters. All choices preserve the exact same finite coefficient words, including signed zero. Selecting a shorter reversible view cannot improve model KL or perplexity.
Installation and memory semantics
The six base frames decode into their existing finite FP64 values. Native installation first casts those values to FP32. Sparse binary16 coefficients or the FP64 product of binary16 low-rank factors are then added to that resident FP32 base in FP64, and the result is installed in FP32. The original resident bias plus paid binary16 intercept follows the same addition/cast rule. Adding a reserve to the original uncast FP64 base changes the model and does not satisfy this release's contract.
v1_bundle_operator.py reconstructs at most one 64 × 64 floating weight tile
at a time, including the native installation casts. Whole scalar frames are
unpacked into bounded chunks. It holds the paid frames, decoded reserve
arrays, input, output and bounded numerical scratch. Its FP64 accumulation
order differs from native FP32 BLAS; it is a correctness reference, not
native neural inference, a GPU kernel or a latency claim. Declared scratch
array bounds exclude immutable paid bytes and decoded reserve arrays and are
not a measurement of total process RSS.
decode_bundle(..., resident_bias=..., decode_matrices=True) deliberately
materializes all six full installed FP32 matrices. The scientific native
model diagnostic uses those matrices in an otherwise FP32 model to evaluate
its actual output. It does not execute a fused packed low-bit network and
does not demonstrate compressed execution memory or speed. The six changed
weights contain 7,077,888 parameters; their FP32 materialization alone costs
28,311,552 bytes, before the remaining model and framework allocations.
Sparse additions are applied directly on their paid shared support. Dense factor products evaluated in complete BLAS calls and in tiled calls can have different FP64 summation rounding. A final FP32 rounding tie can in principle expose that difference. The selected-model reference audit reports actual finite weight agreement and action errors for its tested cases; a passing case is not a universal exact-bit theorem for all factor values, BLAS libraries or hardware. Exact installed checkpoint values and the native decoder remain the authority for the scientific model scores.
The actual-case receipt
results/v1_selected_reference_operator_audit.json checks the four declared
selection roles, the strongest admitted factor control, and a source sparse
control. Those six labels represent five distinct paid bundles because the
extreme and source-extreme roles alias the same model. Every reconstructed
FP32 weight word agrees with the complete native decoder in these cases.
The largest FP64 reference-versus-dense action discrepancy is
5.684341886080802e-14, across deterministic random inputs and eight fixed
stored calibration positions per case. The audit took 8.83 seconds and ran
no neural forward pass, fresh NLL, fitting or selection. Its activation
receipt records the actual samples-by-input cache layout.
Rebuilding real-model evidence
The collection, base construction, sparse repair, low-rank repair and final
native evaluation each have separate protocols, source/input hashes and
receipts under results/. The fit uses fixed calibration/development
positions and never reads fresh NLL for optimization. Finite checkpoint
compilation and decode precede its score. Source or input changes after a
freeze are rejected. Existing started journals must not be deleted to obtain
an unreported repeat of fresh evaluation. Follow the agent implementation
guide and the final research-status document for the exact rebuild order and
selection criteria rather than copying old private absolute paths.
The final model experiment changes six weights in only the first decoder block. It is an informative small-model research diagnostic. It supplies no whole-model frontier comparison, broad downstream task suite, packed GPU benchmark or established world-leading PTQ result. Public synthetic format checks and genuine native model measurements have distinct evidence scopes.