Skip to content

Run frontier MoE models on hardware you already own — pure C, zero deps, experts streamed from disk. Tiny engine, immense model. 🐦

C
4.7 KB
Raw Blame
"""A fake Qwen-Image pipeline directory and the stub engine, for the tests.

The directory has the real checkpoint's layout (model_index.json at the root,
no config.json, one folder per component, processor/tokenizer.json) and
safetensors files whose headers name real tensor names with tiny shapes. The
data is zeros: nothing here reads it, the planner and `coli info` only parse
headers. The engine is tools/qwenimage_stub.py.
"""
import json
import os
import struct
from pathlib import Path

C_DIR = Path(__file__).resolve().parent.parent
STUB = C_DIR / "tools" / "qwenimage_stub.py"

INDEX = {
    "_class_name": "QwenImage21Pipeline",
    "_diffusers_version": "0.37.0.dev0",
    "processor": ["transformers", "Qwen3VLProcessor"],
    "scheduler": ["diffusers", "FlowMatchEulerDiscreteScheduler"],
    "text_encoder": ["transformers", "Qwen3VLForConditionalGeneration"],
    "transformer": ["diffusers", "QwenImage21Transformer2DModel"],
    "vae": ["diffusers", "AutoencoderKLQwenImage21"],
}

# (name, dtype, shape) per component. The text encoder carries the three kinds
# of tensor the planner tells apart: language model (loaded), vision tower and
# lm_head (left on disk).
TENSORS = {
    "text_encoder": [
        ("model.language_model.embed_tokens.weight", "BF16", (1000, 64)),
        ("model.language_model.layers.0.self_attn.q_proj.weight", "BF16", (64, 64)),
        ("model.language_model.layers.0.mlp.gate_proj.weight", "BF16", (192, 64)),
        ("model.language_model.layers.0.input_layernorm.weight", "BF16", (64,)),
        ("model.language_model.norm.weight", "BF16", (64,)),
        ("model.visual.blocks.0.attn.qkv.weight", "BF16", (96, 32)),
        ("lm_head.weight", "BF16", (1000, 64)),
    ],
    "transformer": [
        ("img_in.weight", "BF16", (128, 64)),
        ("transformer_blocks.0.attn.to_q.weight", "BF16", (128, 128)),
        ("transformer_blocks.0.img_mlp.net.0.proj.weight", "BF16", (384, 128)),
        ("norm_out.linear.bias", "BF16", (256,)),
    ],
    "vae": [
        ("decoder.conv_in.weight", "F32", (64, 16, 3, 3, 3)),
        ("decoder.conv_in.bias", "F32", (64,)),
    ],
}
_SIZES = {"BF16": 2, "F32": 4}


def elements(shape):
    total = 1
    for dim in shape:
        total *= dim
    return total


def expected_resident(component):
    """What the planner must report for one component of this fixture."""
    total = 0
    for name, dtype, shape in TENSORS[component]:
        if component == "text_encoder" and not name.startswith("model.language_model."):
            continue
        if component == "vae":
            total += elements(shape) * _SIZES[dtype]
        elif len(shape) == 2:
            total += elements(shape) + shape[0] * 4
        else:
            total += elements(shape) * 4
    return total


def write_safetensors(path, tensors):
    header, offset = {}, 0
    for name, dtype, shape in tensors:
        size = elements(shape) * _SIZES[dtype]
        header[name] = {"dtype": dtype, "shape": list(shape),
                        "data_offsets": [offset, offset + size]}
        offset += size
    raw = json.dumps(header).encode("utf-8")
    raw += b" " * ((8 - len(raw) % 8) % 8)
    with open(path, "wb") as handle:
        handle.write(struct.pack("<Q", len(raw)))
        handle.write(raw)
        handle.truncate(8 + len(raw) + offset)


def make_fake_pipeline(root, tokenizer=True, license_text="Qwen RESEARCH LICENSE AGREEMENT\n"):
    root = Path(root)
    root.mkdir(parents=True, exist_ok=True)
    (root / "model_index.json").write_text(json.dumps(INDEX), encoding="utf-8")
    for part in ("processor", "scheduler", "text_encoder", "transformer", "vae"):
        (root / part).mkdir(exist_ok=True)
    if tokenizer:
        (root / "processor" / "tokenizer.json").write_text("{}", encoding="utf-8")
    (root / "scheduler" / "scheduler_config.json").write_text(
        json.dumps({"_class_name": "FlowMatchEulerDiscreteScheduler"}), encoding="utf-8")
    (root / "transformer" / "config.json").write_text(
        json.dumps({"_class_name": "QwenImage21Transformer2DModel"}), encoding="utf-8")
    write_safetensors(root / "text_encoder" / "model-00001-of-00001.safetensors",
                      TENSORS["text_encoder"])
    write_safetensors(root / "transformer" / "diffusion_pytorch_model.safetensors",
                      TENSORS["transformer"])
    write_safetensors(root / "vae" / "diffusion_pytorch_model.safetensors", TENSORS["vae"])
    if license_text:
        (root / "LICENSE").write_text(license_text, encoding="utf-8")
    return str(root)


def stub_env(delay=0.0, **extra):
    env = dict(os.environ)
    env["QWENIMAGE_STUB_DELAY"] = str(delay)
    env.pop("COLI_IMAGE_PROTOCOL", None)
    env.update({key: str(value) for key, value in extra.items()})
    return env