10EROS_1.5_fp8_exp_learned

10Eros v1.5 — quality-first mixed FP8/BF16 checkpoint

This repository contains a quality-focused highly optimized mixed-precision FP8 version of TenStrip/LTX2.3-10Eros v1.5 for ComfyUI. It is intended for machines that cannot comfortably run the full BF16 checkpoint while preserving the original all-in-one structure: transformer, text encoder, video and audio VAEs, and vocoder remain packaged together.

The primary artifact is:

10Eros_v1.5_fp8mixed_experimental_learned.safetensors

The exp in the repository name and experimental in the checkpoint name are deliberate. They refer specifically to this project's learned-rounding, multi-candidate selection, and BF16-rescue treatment. Although the underlying tools and ComfyUI FP8 representation are established components, this combined quality-optimization procedure is an experimental application by the converter author and is not presented as a standard or generally established quantization recipe. The label does not mean that the 10Eros base model itself or the checkpoint container format is experimental.

The checkpoint is accompanied by a SHA-256 sidecar and a detailed .quantization.json report. It is an independent quantization of the creator's v1.5 BF16 release, not an official TenStrip artifact, and is not claimed to be bit-identical to earlier creator FP8 conversions.

Content notice: the source repository is marked Not-For-All-Audiences on Hugging Face. The same usage and content considerations apply to this precision-converted derivative.

Artifact summary

Why this is quality-first

A direct BF16-to-FP8 cast applies the same basic treatment everywhere, including layers that contribute little to size reduction or are poor candidates for low precision. This conversion instead combines structural selectivity, measured per-matrix candidate selection, and a limited return to BF16.

1. Quantize only the payload-heavy, verified matrix set

Exactly 1,232 matrices in transformer blocks 2 through 45 are eligible. They represent only 20.7% of the source tensor count but about 31.62 GiB, or 73.6%, of its payload. Targeting this minority captures most of the size reduction without quantizing every tensor in the model.

The target set is an exact allowlist covering heavy Q/K/V/output projections for video attention, audio attention, and audio/video cross-attention, plus selected video and audio feed-forward projections. It is not selected by broad name or dtype heuristics.

The following remain byte-identical to the BF16 source:

• transformer blocks 0, 1, 46, and 47;
• gates, normalization layers, embeddings, and biases;
• the text encoder;
• the video and audio VAEs;
• the vocoder, connectors, and every other non-target tensor;
• the 81 target matrices selected for automatic BF16 rescue.

Preserving these components avoids spending approximation error on model infrastructure that offers relatively little checkpoint-size benefit.

2. Apply learned rounding to tensor quantization

Ordinary quantization uses a fixed rule to round BF16 values onto the available FP8 values. This project adds an optimization-based machine-learning step during conversion: for each target matrix, learned rounding searches for FP8 rounding decisions that reconstruct the source weight more accurately, especially along important weight-derived directions.

This is not model retraining or fine-tuning. It uses no prompts, generated samples, training dataset, or captured activations, and it does not change the model architecture. Learning happens only while producing candidate quantized weights; the stored checkpoint remains an ordinary FP8 weight plus scale in the ComfyUI format.

Benchmark the learning settings before production

The rank choices were not guessed from one convenient layer. RTX 4080 benchmark passes covered attention, cross-modal attention, and feed-forward roles across early, middle, and late transformer blocks. The completed FP8 campaign contains 1,255 successful benchmark rows across 165 unique matrices, with no failed candidates and no result exceeding the production raw-error ceiling.

That evidence selected three global learned-rank fractions:

top_p = 0.125, 0.40, 1.00

Here top_p is a learned-rank fraction, not a text-generation sampling setting. It controls how much of the matrix's dominant weight-derived subspace is included in the optimization objective: lower values are narrower and less expensive, while higher values cover more directions at greater conversion cost.

The three choices cover low-, middle-, and high-rank behavior without a brittle per-layer override table.

Learn and choose the representation separately for every matrix

Every non-rescued matrix evaluates four same-size alternatives:

• ordinary per-tensor absmax-scaled FP8 E4M3;
• learned FP8 at top_p=0.125;
• learned FP8 at top_p=0.40;
• learned FP8 at top_p=1.00.

The final checkpoint selected 100 low-rank, 744 middle-rank, 216 high-rank, and 91 ordinary scaled representations. Learned rounding is therefore not presumed to win: the simple scaled representation remains a real per-matrix fallback.

Candidate scoring combines full-matrix normalized reconstruction error with error in a shared, deterministic rank-64 dominant subspace. A 0.5% projected improvement deadband rejects meaningless learned wins, while raw-error guards prevent a projected improvement from hiding an excessive whole-matrix regression. Raw error breaks near-ties.

3. Rescue the least tolerant conversions to BF16

Before learned conversion, all 1,232 targets receive an inexpensive baseline FP8 scan. The worst baseline candidates that fit a 1,024 MiB allowance are removed from the quantization set and copied byte-for-byte from the source.

For v1.5 this rescued 81 matrices using 1,073,739,313 bytes. The budget is bounded: it protects the most difficult layers while preserving most of the space saving.

4. Validate and fail closed

The converter refuses silent optimizer rank reduction after an out-of-memory condition and enforces a maximum selected raw NRMSE of 0.08. It streams the checkpoint rather than loading the complete model into memory, keeps output as .partial until validation succeeds, checks final tensor keys, shapes, dtypes, metadata and byte counts, and byte-compares every preserved tensor with the BF16 source. The JSON report records every candidate and rescue decision; the SHA-256 sidecar protects artifact integrity.

This is weight-only quantization. It does not use activation calibration or claim activation-aware optimization. Source BF16 biases are preserved rather than applying a synthetic correction.

Checkpoint format

This is a ComfyUI mixed-precision safetensors checkpoint. Every FP8 layer has:

• an FP8 E4M3 weight;
• a scalar FP32 weight_scale;
• a comfy_quant descriptor;
• a matching entry in ComfyUI's _quantization_metadata map.

At inference, the representation follows:

approximated_weight = fp8_weight × weight_scale

Layers absent from the quantization map load normally in BF16. Tensor names and shapes are preserved, so LoRAs made for the v1.5 architecture are expected to map through ComfyUI's normal LoRA patching path. Check the console for unmapped keys, dtype problems, or out-of-memory warnings; no specific LoRA should be considered validated unless that exact combination has been tested.

Validation and limitations

Development included structural comparison with the creator's v1.4 fp8mixed_learned checkpoint, inspection of all source keys and shapes, targeted numerical comparison, extensive RTX 4080 candidate benchmarking, final structural and preserved-byte validation, and practical ComfyUI testing. An otherwise identical scaled-FP8 infrastructure artifact also loaded and generated successfully before the learned build was finalized.

Numerical reconstruction improvements do not guarantee that every prompt or seed will be perceptually better. Motion, faces, fine texture, temporal consistency, speech, effects, music, and audio/video synchronization still need to be judged through controlled generation comparisons.

Compatibility and expected hardware

The checkpoint targets a current ComfyUI installation with native mixed-precision quantization support. It has been exercised on an RTX 4080 with 16 GB VRAM using ComfyUI model management and offloading. Actual memory use depends on resolution, frame count, workflow, attention backend, loaded LoRAs, and other active models; 16 GB compatibility is not a guarantee for every workflow or lower-memory GPU.

Use the model-loading workflow recommended by the original 10Eros repository and its associated ComfyUI nodes and workflows. This is a precision-converted artifact, not a different architecture or inference pipeline.

An optimized sample workflow is available in this model repository's workflows folder.

Provenance and acknowledgements

• Base checkpoint and model work: TenStrip/LTX2.3-10Eros.
• The creator's v1.4 fp8mixed_learned release, credited there to S1LV3RC01N, provided a structural reference for the target layout and ComfyUI representation. Its weights were not copied into v1.5.
• Learned-rounding machinery is based on silveroxides/convert_to_quant, with project-specific candidate selection, BF16 rescue, streaming, validation, reporting, and resume safeguards around it.
• Runtime representation follows ComfyUI's quantization format.
• Converter source, runbooks, benchmark protocol, and retained evidence are in LordLocksley/ltx23-10eros-fp8-quantization.

No ownership of the underlying model or training data is claimed. This conversion does not grant additional rights beyond those associated with the source model and its dependencies. Review and comply with the original model's terms, content notice, and applicable licenses before downloading, redistributing, or using this derivative.