Krea-2-Turbo-FP8 (transformer, W8A8)

FP8 (W8A8) quantization of the krea/Krea-2-Turbo transformer (DiT), made with NVIDIA TensorRT Model Optimizer (mtq.quantize + mtq.compress, calibrated on a small diverse prompt set at 768²).

• ~12.8 GB vs ~25 GB bf16 — fits comfortably with the rest of the pipeline.
• Near-bf16 image quality. In controlled same-prompt/same-seed testing, FP8 is visually ~indistinguishable from bf16 and preserves the fine "atmosphere"/detail that a 4-bit NVFP4 (W4A4) version slightly softens. Quality ladder observed: bf16 ≈ FP8 > NVFP4-AWQ > NVFP4.
• This repo is the transformer only. Use krea/Krea-2-Turbo's text_encoder (Qwen3-VL) + vae + tokenizer/scheduler.

Companion (smaller / one-card): sakamakismile/Krea-2-Turbo-NVFP4-AWQ — ~7.2 GB W4A4 (AWQ-Lite), fits a single 16 GB card. Pick FP8 for fidelity, AWQ for size.

FP8 vs NVFP4-AWQ — same prompt, same seed

Each pair below is rendered from the same prompt and the same seed, 8 steps, 1024×1024, guidance 0.0 — FP8 (W8A8) on the left, NVFP4-AWQ (W4A4) on the right. FP8 keeps both weights and activations at 8-bit, so at a fixed seed it tracks the bf16 reference almost exactly and the transformer stays ~12.8 GB. NVFP4-AWQ trades ~5.6 GB for a smaller ~7.2 GB transformer that fits a single 16 GB card, using AWQ-Lite weight-clipping to recover most of the 4-bit weight error. The honest caveat: because W4A4 also quantizes activations, each layer's output shifts slightly and the few-step denoise trajectory diverges — so the right image is often a different-but-coherent sibling composition, not a blurred or degraded copy of the FP8 frame.

Same prompt and seed: both renders keep the moonlit thatched kura, warm-lit lattice window, glowing stone lantern, full moon and foreground bellflowers, with the same nocturnal palette and mood. But this is not a pixel-for-pixel copy — because NVFP4-AWQ quantizes activations to 4-bit, the 8-step denoise trajectory diverges from the FP8 (left) frame, so the right image is a coherent sibling composition: the farmhouse sits closer/larger in the crop and the foreground bellflower mass is denser and taller. The shift is trajectory divergence at a fixed seed, not degradation — the W4A4 transformer stays sharp and structurally intact at roughly half the size (~7.2 GB vs ~12.8 GB), fitting a single 16 GB card.

Same seed and prompt, but at W4A4 the activation quantization nudges each layer's output and the 8-step denoise trajectory diverges: NVFP4-AWQ (7.2 GB) renders a coherent SIBLING of the FP8 (W8A8, 12.8 GB) freckled portrait — same subject, window-light setup and overall look, but a slightly different pose, gaze, hair fall, crop and freckle distribution rather than a frame-for-frame copy. Detail holds up — sharp eyes with clean catchlights, well-defined freckles, preserved skin micro-texture, and matched brightness/contrast/color tone — with no banding, color shift, or structural breakdown; this is trajectory divergence at 4-bit, not quality degradation.

Both at seed 123, 8 steps, 1024px, FP8 (left) and NVFP4-AWQ (right) render the same warm-lit red fox in snow as different sibling poses. FP8 frames a closer three-quarter-left stance with the bushy tail raised behind; W4A4-AWQ shows a more frontal, pulled-back stance with front paws and dark stockings visible and the tail held lower to the right. This is few-step denoise trajectory divergence from 4-bit activation quantization, not degradation: AWQ holds comparable guard-hair fur micro-texture, sharp eyes, dark leg markings, and granular snow, with no visible blur, banding, smearing, or color drift.

Same seed, same prompt: both renders produce the same rain-soaked neon boulevard — matching camera angle, vanishing point, deep-blue rainy sky and glossy wet-pavement reflections — but FP8 (left) and NVFP4-AWQ (right) resolve the dense signage, pedestrian/umbrella placement and exact glyphs as slightly different coherent siblings, the expected W4A4 denoise-trajectory divergence rather than a quality drop; AWQ keeps neon saturation, reflection sharpness and fine sign detail essentially on par with FP8.

Pick NVFP4-AWQ for size — half the transformer footprint (~7.2 GB) on a single 16 GB card; pick FP8 for maximum fidelity to the bf16 reference.

Usage (verified)

Requires diffusers from source (Krea2Pipeline is 0.39-dev, not on PyPI yet) + nvidia-modelopt + a recent torch on Blackwell (FP8).

import torch
import modelopt.torch.opt as mto
from diffusers import Krea2Pipeline, Krea2Transformer2DModel

BASE = "krea/Krea-2-Turbo"
FP8  = "sakamakismile/Krea-2-Turbo-FP8"   # local path or hf snapshot

# rebuild the FP8 transformer from the modelopt state on the base structure
t = Krea2Transformer2DModel.from_pretrained(BASE, subfolder="transformer", torch_dtype=torch.bfloat16, device_map="auto")
mto.restore(t, f"{FP8}/modelopt_state.pth")

pipe = Krea2Pipeline.from_pretrained(BASE, transformer=t, torch_dtype=torch.bfloat16).to("cuda")
img = pipe("a fox in the snow", num_inference_steps=8, guidance_scale=0.0).images[0]
img.save("out.png")

modelopt_state.pth is the reliable reload (proven). diffusion_pytorch_model-*.safetensors is the save_pretrained form of the same quantized transformer.

License & attribution

Inherits the krea-2-community-license from the base model krea/Krea-2-Turbo by Krea — please read and follow it. Community quantization; no affiliation with Krea.