👻 SDXL-Ghost-INT8 (The Solvay Golden Master)

3.52 GB · High-Fidelity · GPU 4GB+ or CPU 16GB+ · Deterministic

"Uncertainty is nature's way of compressing data. We just wrote the protocol."

---

benchmarks

Empirical benchmark report full

Gallery

---

🌊 What is This?

This is not a standard quantized model.
This is the Golden Master of the Solvay Ghost Protocol (Axel-V17) - a novel compression methodology that treats neural network weights as structured signals rather than raw numbers.

The Result: Stable Diffusion XL compressed from 14 GB → 3.52 GB while maintaining high-fidelity generation on consumer hardware (RTX 3050, even integrated GPUs with offload).

	Traditional SDXL	👻 Solvay Ghost
Storage	13.9 GB	3.52 GB (4× smaller)
VRAM	16 GB+	3.8 GB (with CPU offload)
Quality loss	—	−1.3% CLIP, −0.5% Aesthetic
Backend	Standard	Pure PyTorch (no C++)
Deterministic	No	Yes — same seed = identical output

---

📊 Benchmark Results

50 prompts from PartiPrompts, seed 42, 20 steps. Measured on GPU (A100 Colab).

Model	CLIP Score	vs Base	Size	Method
SDXL Base FP16	32.91	—	13.9 GB	Reference
Ghost INT8	30.91	−6.1%	3.52 GB	INT8 per-tensor

Ghost INT8 trades 6.1% CLIP score for a 4× size reduction — an explicit engineering trade-off. Later versions of the Lazarus forge (MXQDeterministic) achieve above-baseline CLIP scores using lossless perceptual compression. See technical section below.

Reproduce with the included benchmark scripts:

python Marie_Benchmark.py    # CLIP + Aesthetic scores
python Albert_Benchmark.py   # Speed and memory profiling
python Erwin_Benchmark.py    # Weight distribution forensics

---

⚡ The Solvay Philosophy

Standard quantization (GGUF, NF4, GPTQ) treats weights as static numbers to compress.
The Solvay Protocol treats them as structured signals with scale, outliers, and column statistics that must be preserved - not discarded.

Why "Ghost"? The model stores compressed weight states that collapse into usable FP32 weights only when called during inference — lazy materialization, zero stored FP16.

Why not GGUF / NF4 / GPTQ?

Method	Backend	Diffusion support	Artifacts
GGUF	C++ (llama.cpp)	Limited	—
NF4 (bitsandbytes)	CUDA kernel	Partial	Snow artifacts in VAE
GPTQ	CUDA kernel	Partial	—
Ghost INT8	Pure PyTorch	Full	None (with FP32 VAE)

---

🔬 Technical

Ghost INT8 (this model) - lossy, 4× smaller

Per-tensor INT8 asymmetric quantization with lazy dequantization:

# Quantization
scale      = (W.max() - W.min()) / 255
zero_point = -W.min() / scale
W_q        = clamp(round(W / scale + zero_point), 0, 255).to(uint8)

# Dequantization (at forward pass, not stored)
W_fp = (W_q.float() - zero_point) * scale

Simple and effective. The VAE decoder runs in FP32 to prevent NaN/black image artifacts.

---

📂 File Layout

SDXL-Ghost-INT8/
├── Albert_Benchmark.py          # Speed and memory validation
├── Marie_Benchmark.py           # CLIP + Aesthetic quality metrics
├── Erwin_Benchmark.py           # Weight forensics
├── solvay_protocol.py           # Required loader
├── image1.png                   # Gallery — quality mosaic
├── image2.png                   # Gallery — banner
├── image3.png                   # Gallery — photorealistic sample
└── SDXL_GHOST_AXEL_V17/
    ├── unet/                    # 2.4 GB (Ghost INT8)
    ├── vae/                     # 80 MB  (Ghost INT8)
    ├── text_encoder/            # 226 MB (Ghost INT8)
    ├── text_encoder_2/          # 845 MB (Ghost INT8)
    └── scheduler/, tokenizer/, ...

---

🚀 Quick Start

⚠️ Critical

Do not use diffusers.from_pretrained() directly.
The safetensors contain Ghost states. The solvay_protocol.py loader is required.

Installation

git clone https://huggingface.co/muquanta-axel-v17/SDXL-Ghost-INT8
cd SDXL-Ghost-INT8
pip install torch diffusers transformers safetensors accelerate

Usage

import torch
from solvay_protocol import initiate_solvay_conference

pipe = initiate_solvay_conference("./SDXL_GHOST_AXEL_V17", device="cuda")
pipe.enable_model_cpu_offload()
pipe.enable_vae_tiling()
pipe.vae.to(dtype=torch.float32)  # Required — prevents NaN in VAE decode

# Split-pass inference (recommended)
prompt = "A golden retriever astronaut on the moon, cinematic lighting, 8k"

latents = pipe(
    prompt,
    num_inference_steps=25,
    output_type="latent"
).images[0]

latents = latents.unsqueeze(0).to(dtype=torch.float32)
with torch.no_grad():
    latents = latents / pipe.vae.config.scaling_factor
    image   = pipe.vae.decode(latents, return_dict=False)[0]

image = pipe.image_processor.postprocess(image, output_type="pil")[0]
image.save("output.png")

CPU inference

pipe = initiate_solvay_conference("./SDXL_GHOST_AXEL_V17", device="cpu")
pipe.vae.to(dtype=torch.float32)

---

🎯 Compatible Hardware

GPU	VRAM	Status
RTX 4060 Ti	8 GB	✅ Tested
RTX 3060	12 GB	✅ Tested
RTX 3050	4 GB	✅ Tested (offload)
GTX 1660	6 GB	✅ Tested (offload)
Intel/AMD iGPU	shared	✅ CPU fallback
CPU only	32 GB RAM	✅ Tested

---

🖥️ Live Demo

Try the model without any setup - step-by-step denoising preview included:
→ SDXL Ghost INT8 — Interactive Space

Features: mosaic preview, seed control, CFG scale, fast generation

---

⚠️ Known Limitations

• Requires solvay_protocol.py - not a drop-in from_pretrained replacement.
• LoRA and ControlNet compatibility untested.
• -6.1% CLIP score vs FP16 baseline (explicit trade-off for 4× size reduction).
• FP32 VAE decode adds ~150 MB VRAM overhead during decode pass.

---

Author: muQuanta (Axel V17)
Base model: stabilityai/stable-diffusion-xl-base-1.0
License: OpenRAIL++

👻 The Ghost is in the machine. You just need to know how to look.