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 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.
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.
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.
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.
