diffsynth-engine 0.6.1.dev34__py3-none-any.whl → 0.6.1.dev35__py3-none-any.whl

diffsynth_engine/pipelines/z_image.py

@@ -0,0 +1,377 @@
+import torch
+import torch.distributed as dist
+import math
+import json
+from typing import Callable, List, Dict, Tuple, Optional, Union
+from tqdm import tqdm
+
+from diffsynth_engine.configs import (
+    ZImagePipelineConfig,
+    ZImageStateDicts,
+)
+from diffsynth_engine.models.basic.lora import LoRAContext
+
+from diffsynth_engine.models.z_image import (
+    ZImageDiT,
+    Qwen3Model,
+    Qwen3Config,
+)
+from diffsynth_engine.tokenizers.qwen2 import Qwen2TokenizerFast
+from diffsynth_engine.utils.constants import (
+    Z_IMAGE_TEXT_ENCODER_CONFIG_FILE,
+    Z_IMAGE_TOKENIZER_CONF_PATH,
+)
+from diffsynth_engine.models.flux import FluxVAEDecoder
+from diffsynth_engine.pipelines import BasePipeline, LoRAStateDictConverter
+from diffsynth_engine.pipelines.utils import calculate_shift
+from diffsynth_engine.algorithm.noise_scheduler import RecifitedFlowScheduler
+from diffsynth_engine.algorithm.sampler import FlowMatchEulerSampler
+from diffsynth_engine.utils.parallel import ParallelWrapper
+from diffsynth_engine.utils import logging
+from diffsynth_engine.utils.fp8_linear import enable_fp8_linear
+from diffsynth_engine.utils.download import fetch_model
+
+logger = logging.get_logger(__name__)
+
+
+class ZImageLoRAConverter(LoRAStateDictConverter):
+    def _from_diffusers(self, lora_state_dict: Dict[str, torch.Tensor]) -> Dict[str, Dict[str, torch.Tensor]]:
+        dit_dict = {}
+        for key, param in lora_state_dict.items():
+            if "lora_A.weight" in key:
+                lora_b_key = key.replace("lora_A.weight", "lora_B.weight")
+                target_key = key.replace(".lora_A.weight", "").replace("transformer.", "")
+
+                if "attn.to_out.0" in target_key:
+                    target_key = target_key.replace("attn.to_out.0", "attn.to_out")
+
+                dit_dict[target_key] = {
+                    "down": param,
+                    "up": lora_state_dict[lora_b_key],
+                    "alpha": lora_state_dict.get(key.replace("lora_A.weight", "alpha"), None),
+                }
+        return {"dit": dit_dict}
+
+    def convert(self, lora_state_dict: Dict[str, torch.Tensor]) -> Dict[str, Dict[str, torch.Tensor]]:
+        return self._from_diffusers(lora_state_dict)
+
+
+class ZImagePipeline(BasePipeline):
+    lora_converter = ZImageLoRAConverter()
+
+    def __init__(
+        self,
+        config: ZImagePipelineConfig,
+        tokenizer: Qwen2TokenizerFast,
+        text_encoder: Qwen3Model,
+        dit: ZImageDiT,
+        vae_decoder: FluxVAEDecoder,
+    ):
+        super().__init__(
+            vae_tiled=config.vae_tiled,
+            vae_tile_size=config.vae_tile_size,
+            vae_tile_stride=config.vae_tile_stride,
+            device=config.device,
+            dtype=config.model_dtype,
+        )
+        self.config = config
+
+        # Scheduler
+        self.noise_scheduler = RecifitedFlowScheduler(shift=3.0, use_dynamic_shifting=True)
+        self.sampler = FlowMatchEulerSampler()
+        self.tokenizer = tokenizer
+        # Models
+        self.text_encoder = text_encoder
+        self.dit = dit
+        self.vae_decoder = vae_decoder
+
+        self.model_names = ["text_encoder", "dit", "vae_decoder"]
+
+    @classmethod
+    def from_pretrained(cls, model_path_or_config: str | ZImagePipelineConfig) -> "ZImagePipeline":
+        if isinstance(model_path_or_config, str):
+            config = ZImagePipelineConfig(model_path=model_path_or_config)
+        else:
+            config = model_path_or_config
+
+        logger.info(f"Loading state dict from {config.model_path} ...")
+
+        model_state_dict = cls.load_model_checkpoint(
+            config.model_path, device="cpu", dtype=config.model_dtype, convert_dtype=False
+        )
+
+        if config.vae_path is None:
+            config.vae_path = fetch_model(config.model_path, path="vae/diffusion_pytorch_model.safetensors")
+        logger.info(f"Loading VAE from {config.vae_path} ...")
+        vae_state_dict = cls.load_model_checkpoint(config.vae_path, device="cpu", dtype=config.vae_dtype)
+
+        if config.encoder_path is None:
+            config.encoder_path = fetch_model(config.model_path, path="text_encoder")
+        logger.info(f"Loading Text Encoder from {config.encoder_path} ...")
+        text_encoder_state_dict = cls.load_model_checkpoint(
+            config.encoder_path, device="cpu", dtype=config.encoder_dtype
+        )
+
+        state_dicts = ZImageStateDicts(
+            model=model_state_dict,
+            vae=vae_state_dict,
+            encoder=text_encoder_state_dict,
+        )
+        return cls.from_state_dict(state_dicts, config)
+
+    @classmethod
+    def from_state_dict(cls, state_dicts: ZImageStateDicts, config: ZImagePipelineConfig) -> "ZImagePipeline":
+        if config.parallelism > 1:
+            pipe = ParallelWrapper(
+                cfg_degree=config.cfg_degree,
+                sp_ulysses_degree=config.sp_ulysses_degree,
+                sp_ring_degree=config.sp_ring_degree,
+                tp_degree=config.tp_degree,
+                use_fsdp=config.use_fsdp,
+            )
+            pipe.load_module(cls._from_state_dict, state_dicts=state_dicts, config=config)
+        else:
+            pipe = cls._from_state_dict(state_dicts, config)
+        return pipe
+
+    @classmethod
+    def _from_state_dict(cls, state_dicts: ZImageStateDicts, config: ZImagePipelineConfig) -> "ZImagePipeline":
+        init_device = "cpu" if config.offload_mode is not None else config.device
+        with open(Z_IMAGE_TEXT_ENCODER_CONFIG_FILE, "r", encoding="utf-8") as f:
+            qwen3_config = Qwen3Config(**json.load(f))
+        text_encoder = Qwen3Model.from_state_dict(
+            state_dicts.encoder, config=qwen3_config, device=init_device, dtype=config.encoder_dtype
+        )
+        tokenizer = Qwen2TokenizerFast.from_pretrained(Z_IMAGE_TOKENIZER_CONF_PATH)
+        vae_decoder = FluxVAEDecoder.from_state_dict(state_dicts.vae, device=init_device, dtype=config.vae_dtype)
+
+        with LoRAContext():
+            dit = ZImageDiT.from_state_dict(
+                state_dicts.model,
+                device=("cpu" if config.use_fsdp else init_device),
+                dtype=config.model_dtype,
+            )
+            if config.use_fp8_linear:
+                enable_fp8_linear(dit)
+
+        pipe = cls(
+            config=config,
+            tokenizer=tokenizer,
+            text_encoder=text_encoder,
+            dit=dit,
+            vae_decoder=vae_decoder,
+        )
+        pipe.eval()
+
+        if config.offload_mode is not None:
+            pipe.enable_cpu_offload(config.offload_mode, config.offload_to_disk)
+
+        if config.model_dtype == torch.float8_e4m3fn:
+            pipe.dtype = torch.bfloat16
+            pipe.enable_fp8_autocast(
+                model_names=["dit"], compute_dtype=pipe.dtype, use_fp8_linear=config.use_fp8_linear
+            )
+
+        if config.use_torch_compile:
+            pipe.compile()
+
+        return pipe
+
+    def update_weights(self, state_dicts: ZImageStateDicts) -> None:
+        self.update_component(self.dit, state_dicts.model, self.config.device, self.config.model_dtype)
+        self.update_component(
+            self.text_encoder, state_dicts.text_encoder, self.config.device, self.config.encoder_dtype
+        )
+        self.update_component(self.vae_decoder, state_dicts.vae, self.config.device, self.config.vae_dtype)
+
+    def compile(self):
+        if hasattr(self.dit, "compile_repeated_blocks"):
+            self.dit.compile_repeated_blocks()
+
+    def load_loras(self, lora_list: List[Tuple[str, float]], fused: bool = True, save_original_weight: bool = False):
+        assert self.config.tp_degree is None or self.config.tp_degree == 1, (
+            "load LoRA is not allowed when tensor parallel is enabled; "
+            "set tp_degree=None or tp_degree=1 during pipeline initialization"
+        )
+        assert not (self.config.use_fsdp and fused), (
+            "load fused LoRA is not allowed when fully sharded data parallel is enabled; "
+            "either load LoRA with fused=False or set use_fsdp=False during pipeline initialization"
+        )
+        super().load_loras(lora_list, fused, save_original_weight)
+
+    def unload_loras(self):
+        if hasattr(self.dit, "unload_loras"):
+            self.dit.unload_loras()
+        self.noise_scheduler.restore_config()
+
+    def apply_scheduler_config(self, scheduler_config: Dict):
+        self.noise_scheduler.update_config(scheduler_config)
+
+    def prepare_latents(
+        self,
+        latents: torch.Tensor,
+        num_inference_steps: int,
+        mu: float,
+    ):
+        sigmas, timesteps = self.noise_scheduler.schedule(num_inference_steps, mu=mu, sigma_min=0, sigma_max=1.0)
+
+        sigmas = sigmas.to(device=self.device, dtype=self.dtype)
+        timesteps = timesteps.to(device=self.device, dtype=self.dtype)
+        latents = latents.to(device=self.device, dtype=self.dtype)
+
+        return latents, sigmas, timesteps
+
+    def encode_prompt(
+        self,
+        prompt: str,
+        max_sequence_length: int = 512,
+    ):
+        if prompt is None:
+            return None
+        template = "<|im_start|>user\n{}<|im_end|>\n<|im_start|>assistant\n"
+        txt = [template.format(prompt)]
+        text_inputs = self.tokenizer(
+            txt,
+            max_length=max_sequence_length,
+            padding_strategy="max_length",
+        )
+
+        input_ids = text_inputs["input_ids"].to(self.device)
+        attention_mask = text_inputs["attention_mask"].to(self.device).bool()
+        # Encoder forward
+        outputs = self.text_encoder(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            output_hidden_states=True,
+        )
+
+        prompt_embeds = outputs["hidden_states"][-2]
+        embeddings_list = []
+        for i in range(len(prompt_embeds)):
+            embeddings_list.append(prompt_embeds[i][attention_mask[i]])
+        return embeddings_list
+
+    def predict_noise_with_cfg(
+        self,
+        latents: torch.Tensor,
+        timestep: torch.Tensor,
+        prompt_emb: List[torch.Tensor],
+        negative_prompt_emb: List[torch.Tensor],
+        cfg_scale: float = 5.0,
+        cfg_truncation: float = 1.0,
+        cfg_normalization: float = 0.0,  # 0.0 means disabled
+        batch_cfg: bool = False,
+    ):
+        t = timestep.expand(latents.shape[0])
+        t = (1000 - t) / 1000
+        progress = t[0].item()
+
+        current_cfg_scale = cfg_scale
+        if cfg_truncation <= 1.0 and progress > cfg_truncation:
+            current_cfg_scale = 0.0
+
+        do_cfg = current_cfg_scale > 0 and negative_prompt_emb is not None
+
+        if not do_cfg:
+            comb_pred = self.predict_noise(latents, t, prompt_emb)[0]
+        else:
+            if not batch_cfg:
+                positive_noise_pred = self.predict_noise(latents, t, prompt_emb)
+                negative_noise_pred = self.predict_noise(latents, t, negative_prompt_emb)
+            else:
+                latents_input = torch.cat([latents, latents], dim=0)
+                t = torch.cat([t, t], dim=0)
+                prompt_input = prompt_emb + negative_prompt_emb
+
+                noise_pred = self.predict_noise(latents_input, t, prompt_input)
+
+                positive_noise_pred, negative_noise_pred = noise_pred[0], noise_pred[1]
+
+            comb_pred = positive_noise_pred + current_cfg_scale * (positive_noise_pred - negative_noise_pred)
+
+            if cfg_normalization is not None and cfg_normalization > 0:
+                cond_norm = torch.linalg.vector_norm(positive_noise_pred)
+                new_norm = torch.linalg.vector_norm(comb_pred)
+                max_allowed_norm = cond_norm * cfg_normalization
+                new_norm = torch.where(new_norm < 1e-6, torch.ones_like(new_norm), new_norm)
+                scale_factor = max_allowed_norm / new_norm
+                scale_factor = torch.clamp(scale_factor, max=1.0)
+                comb_pred = comb_pred * scale_factor
+
+        comb_pred = -comb_pred.squeeze(1).unsqueeze(0)
+        return comb_pred
+
+    def predict_noise(
+        self,
+        latents: torch.Tensor,
+        timestep: torch.Tensor,
+        prompt_emb: List[torch.Tensor],
+    ):
+        self.load_models_to_device(["dit"])
+
+        latents_list = list(latents.unsqueeze(2).unbind(dim=0))
+
+        noise_pred = self.dit(
+            image=latents_list,
+            timestep=timestep,
+            cap_feats=prompt_emb,
+        )
+        return noise_pred
+
+    @torch.no_grad()
+    def __call__(
+        self,
+        prompt: Union[str, List[str]],
+        negative_prompt: Optional[Union[str, List[str]]] = None,
+        height: int = 1024,
+        width: int = 1024,
+        num_inference_steps: int = 50,
+        cfg_scale: float = 5.0,
+        cfg_normalization: bool = False,
+        cfg_truncation: float = 1.0,
+        seed: Optional[int] = None,
+        progress_callback: Optional[Callable] = None,
+    ):
+        self.validate_image_size(height, width, multiple_of=16)
+
+        self.load_models_to_device(["text_encoder"])
+        prompt_embeds, negative_prompt_embeds = self.encode_prompt(prompt), self.encode_prompt(negative_prompt)
+        self.model_lifecycle_finish(["text_encoder"])
+
+        noise = self.generate_noise((1, 16, height // 8, width // 8), seed=seed, device="cpu", dtype=self.dtype).to(
+            device=self.device
+        )
+        image_seq_len = math.ceil(height // 16) * math.ceil(width // 16)
+
+        mu = calculate_shift(image_seq_len, base_seq_len=256, max_seq_len=4096, base_shift=0.5, max_shift=1.15)
+
+        latents, sigmas, timesteps = self.prepare_latents(noise, num_inference_steps, mu)
+
+        self.sampler.initialize(sigmas=sigmas)
+
+        self.load_models_to_device(["dit"])
+        hide_progress = dist.is_initialized() and dist.get_rank() != 0
+
+        for i, timestep in enumerate(tqdm(timesteps, disable=hide_progress)):
+            timestep = timestep.unsqueeze(0).to(dtype=self.dtype)
+            noise_pred = self.predict_noise_with_cfg(
+                latents=latents,
+                timestep=timestep,
+                prompt_emb=prompt_embeds,
+                negative_prompt_emb=negative_prompt_embeds,
+                batch_cfg=self.config.batch_cfg,
+                cfg_truncation=cfg_truncation,
+                cfg_normalization=cfg_normalization,
+            )
+            latents = self.sampler.step(latents, noise_pred, i)
+            if progress_callback is not None:
+                progress_callback(i, len(timesteps), "DENOISING")
+
+        self.model_lifecycle_finish(["dit"])
+
+        self.load_models_to_device(["vae_decoder"])
+        vae_output = self.decode_image(latents)
+        image = self.vae_output_to_image(vae_output)
+        # Offload all models
+        self.load_models_to_device([])
+        return image

diffsynth_engine/utils/constants.py

@@ -14,6 +14,7 @@ SDXL_TOKENIZER_2_CONF_PATH = os.path.join(CONF_PATH, "tokenizers", "sdxl", "toke
 WAN_TOKENIZER_CONF_PATH = os.path.join(CONF_PATH, "tokenizers", "wan", "umt5-xxl")
 QWEN_IMAGE_TOKENIZER_CONF_PATH = os.path.join(CONF_PATH, "tokenizers", "qwen_image", "tokenizer")
 QWEN_IMAGE_PROCESSOR_CONFIG_FILE = os.path.join(CONF_PATH, "tokenizers", "qwen_image", "qwen2_vl_image_processor.json")
+Z_IMAGE_TOKENIZER_CONF_PATH = os.path.join(CONF_PATH, "tokenizers", "z_image", "tokenizer")
 
 # models
 VAE_CONFIG_FILE = os.path.join(CONF_PATH, "models", "components", "vae.json")
@@ -46,6 +47,8 @@ QWEN_IMAGE_VISION_CONFIG_FILE = os.path.join(CONF_PATH, "models", "qwen_image",
 QWEN_IMAGE_VAE_CONFIG_FILE = os.path.join(CONF_PATH, "models", "qwen_image", "qwen_image_vae.json")
 QWEN_IMAGE_VAE_KEYMAP_FILE = os.path.join(CONF_PATH, "models", "qwen_image", "qwen_image_vae_keymap.json")
 
+Z_IMAGE_TEXT_ENCODER_CONFIG_FILE = os.path.join(CONF_PATH, "models", "z_image", "qwen3_config.json")
+
 # data size
 KB = 1024
 MB = 1024 * KB

diffsynth_engine/utils/process_group.py

@@ -20,7 +20,7 @@ class Singleton:
 
 class ProcessGroupSingleton(Singleton):
     def __init__(self):
-        if not hasattr(self, 'initialized'):
+        if not hasattr(self, "initialized"):
             self.CFG_GROUP: Optional[dist.ProcessGroup] = None
             self.SP_GROUP: Optional[dist.ProcessGroup] = None
             self.SP_ULYSSUES_GROUP: Optional[dist.ProcessGroup] = None

{diffsynth_engine-0.6.1.dev34.dist-info → diffsynth_engine-0.6.1.dev35.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffsynth_engine
-Version: 0.6.1.dev34
+Version: 0.6.1.dev35
 Author: MuseAI x ModelScope
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent

{diffsynth_engine-0.6.1.dev34.dist-info → diffsynth_engine-0.6.1.dev35.dist-info}/RECORD

@@ -1,4 +1,4 @@
-diffsynth_engine/__init__.py,sha256=deLiGEHeQV1Xq7Kd11oRUA28FDegUgXBjlkNwgtVBMw,2290
+diffsynth_engine/__init__.py,sha256=hN0jYaikjhpqHB4Mg-e53h-7ck1DsiY4FBti8K9lN2k,2390
 diffsynth_engine/algorithm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 diffsynth_engine/algorithm/noise_scheduler/__init__.py,sha256=YvcwE2tCNua-OAX9GEPm0EXsINNWH4XvJMNZb-uaZMM,745
 diffsynth_engine/algorithm/noise_scheduler/base_scheduler.py,sha256=3ve4bYxGyfuERynvoNYdFYSk0agdBgXKCeIOS6O6wgI,819
@@ -52,6 +52,7 @@ diffsynth_engine/conf/models/wan/dit/wan_dit_keymap.json,sha256=hfGytOIRkdYFgOR9
 diffsynth_engine/conf/models/wan/vae/wan2.1_vae.json,sha256=eVLTSRqbXm3JD8QDkLbM6vFfCdynlS-8QxqCfi4BzrI,815
 diffsynth_engine/conf/models/wan/vae/wan2.2_vae.json,sha256=pdnYEEZ_GcZHM_iH1y5ASdf_qZUGCOuDEaFmjdg9RKY,1860
 diffsynth_engine/conf/models/wan/vae/wan_vae_keymap.json,sha256=u9MJ3yRL45kdqRVoBnYbHkmuUmOseUFtwte-_9ZvdHc,25224
+diffsynth_engine/conf/models/z_image/qwen3_config.json,sha256=i6AG90_s-q6zkocqYPSkgOfsmGAVPS4bdp7IH5oUf4o,726
 diffsynth_engine/conf/tokenizers/flux/tokenizer_1/merges.txt,sha256=n9aR98gDkhDg_O0VhlRmxlgg0JtjmIsBdL_iXeKZBRo,524619
 diffsynth_engine/conf/tokenizers/flux/tokenizer_1/special_tokens_map.json,sha256=LNs7gzGmDJL8HlWhPp_WH9IpPFpRJ1_czNYreABSUw4,588
 diffsynth_engine/conf/tokenizers/flux/tokenizer_1/tokenizer_config.json,sha256=a9zunMzioWyitMDF7QC0LFDqIl9EcqjEweljopAsKIE,705
@@ -79,9 +80,13 @@ diffsynth_engine/conf/tokenizers/wan/umt5-xxl/special_tokens_map.json,sha256=e4q
 diffsynth_engine/conf/tokenizers/wan/umt5-xxl/spiece.model,sha256=45CaZ7eAZQs1z1Kax4KtK2sm5tH4SdP7tqhykF9FJFg,4548313
 diffsynth_engine/conf/tokenizers/wan/umt5-xxl/tokenizer.json,sha256=bhl7TT29cdoUtOslX0-pHJwfIGiyCi3iRylnyj0iYCs,16837417
 diffsynth_engine/conf/tokenizers/wan/umt5-xxl/tokenizer_config.json,sha256=7Zo6iw-qcacKMoR-BDX-A25uES1N9O23u0ipIeNE3AU,61728
-diffsynth_engine/configs/__init__.py,sha256=vSjJToEdq3JX7t81_z4nwNwIdD4bYnFjxnMZH7PXMKo,1309
+diffsynth_engine/conf/tokenizers/z_image/tokenizer/merges.txt,sha256=iDHk8aBERxNA98CoPXvXEwaluGfpX9hw900MUwipBNU,1671853
+diffsynth_engine/conf/tokenizers/z_image/tokenizer/tokenizer.json,sha256=rrEzB6cazY_oGGHZStVKtonfdzMYgJ7tPL55S0SS2uQ,11422654
+diffsynth_engine/conf/tokenizers/z_image/tokenizer/tokenizer_config.json,sha256=1dCfB7SMMIbFCLMNHJEUvRGJFFt06YKiZTUMkjrNgQE,9732
+diffsynth_engine/conf/tokenizers/z_image/tokenizer/vocab.json,sha256=yhDX6fs-0YV13R4neiV5wW0QjjLydDloSvoOELFECRA,2776833
+diffsynth_engine/configs/__init__.py,sha256=biluGSEw78PPwO7XFlms16iuWXDiM0Eg_qsOMMTY0NQ,1409
 diffsynth_engine/configs/controlnet.py,sha256=f3vclyP3lcAjxDGD9C1vevhqqQ7W2LL_c6Wye0uxk3Q,1180
-diffsynth_engine/configs/pipeline.py,sha256=SLaxFd9mKuJgromrkXpJrsNGAGzMl51Twomc4Qo83Wc,13759
+diffsynth_engine/configs/pipeline.py,sha256=0WmKz_mykmJkRCGwv9DjuN8s27LppkD_Ier4VtovZSg,15307
 diffsynth_engine/kernels/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 diffsynth_engine/models/__init__.py,sha256=8Ze7cSE8InetgXWTNb0neVA2Q44K7WlE-h7O-02m2sY,119
 diffsynth_engine/models/base.py,sha256=svao__9WH8VNcyXz5o5dzywYXDcGV0YV9IfkLzDKews,2558
@@ -142,7 +147,10 @@ diffsynth_engine/models/wan/wan_image_encoder.py,sha256=Vdd39lv_QvOsmPxihZWZZbpP
 diffsynth_engine/models/wan/wan_s2v_dit.py,sha256=j63ulcWLY4XGITOKUMGX292LtSEtP-n8BTvqb98YExU,23615
 diffsynth_engine/models/wan/wan_text_encoder.py,sha256=ePeOifbTI_o650mckzugyWPuHn5vhM-uFMcDVCijxPM,11394
 diffsynth_engine/models/wan/wan_vae.py,sha256=dC7MoUFeXRL7SIY0LG1OOUiZW-pp9IbXCghutMxpXr4,38889
-diffsynth_engine/pipelines/__init__.py,sha256=jh-4LSJ0vqlXiT8BgFgRIQxuAr2atEPyHrxXWj-Ud1U,604
+diffsynth_engine/models/z_image/__init__.py,sha256=d1ztBNgM8GR2_uGwlxOE1Jf5URTq1g-WnmJH7nrMoaY,160
+diffsynth_engine/models/z_image/qwen3.py,sha256=PmT6m46Fc7KZXNzG7ig23Mzj6QfHnMmrpX_MM0UuuYg,4580
+diffsynth_engine/models/z_image/z_image_dit.py,sha256=kGtYzmfzk_FDe7KWfXpJagN7k7ROXl5J01IhRRs-Bsk,23806
+diffsynth_engine/pipelines/__init__.py,sha256=xQUtz2cVmcEInazvT1dqv2HdPiJKmywWTIPfbK5dZXI,662
 diffsynth_engine/pipelines/base.py,sha256=ShRiX5MY6bUkRKfuGrA1aalAqeHyeZxhzT87Mwc30b4,17231
 diffsynth_engine/pipelines/flux_image.py,sha256=L0ggxpthLD8a5-zdPHu9z668uWBei9YzPb4PFVypDNU,50707
 diffsynth_engine/pipelines/hunyuan3d_shape.py,sha256=TNV0Wr09Dj2bzzlpua9WioCClOj3YiLfE6utI9aWL8A,8164
@@ -152,6 +160,7 @@ diffsynth_engine/pipelines/sdxl_image.py,sha256=v7ZACGPb6EcBunL6e5E9jynSQjE7GQx8
 diffsynth_engine/pipelines/utils.py,sha256=HZbJHErNJS1DhlwJKvZ9dY7Kh8Zdlsw3zE2e88TYGRY,2277
 diffsynth_engine/pipelines/wan_s2v.py,sha256=QHlCLMqlmnp55iYm2mzg4qCq4jceRAP3Zt5Mubz3mAM,29384
 diffsynth_engine/pipelines/wan_video.py,sha256=9xjSvQ4mlVEDdaL6QuUURj4iyxhJ2xABBphQjkfzK8s,31323
+diffsynth_engine/pipelines/z_image.py,sha256=gSBhKV7TBL9xvCUrABdZA0kNqQzPuawmEv8OcI6KTcs,14756
 diffsynth_engine/processor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 diffsynth_engine/processor/canny_processor.py,sha256=hV30NlblTkEFUAmF_O-LJrNlGVM2SFrqq6okfF8VpOo,602
 diffsynth_engine/processor/depth_processor.py,sha256=dQvs3JsnyMbz4dyI9QoR8oO-mMFBFAgNvgqeCoaU5jk,1532
@@ -170,7 +179,7 @@ diffsynth_engine/tools/flux_reference_tool.py,sha256=6v0NRZPsDEHFlPruO-ZJTB4rYWx
 diffsynth_engine/tools/flux_replace_tool.py,sha256=AOyEGxHsaNwpTS2VChAieIfECgMxlKsRw0lWPm1k9C0,4627
 diffsynth_engine/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 diffsynth_engine/utils/cache.py,sha256=Ivef22pCuhEq-4H00gSvkLS8ceVZoGis7OSitYL6gH4,2101
-diffsynth_engine/utils/constants.py,sha256=sJio3Vy8i0-PWYRnqquYt6ez9k6Tc9JdjCv6pn2BU_4,3551
+diffsynth_engine/utils/constants.py,sha256=x0-bsPRplW-KkRpLVajuC9Yv6f3QbdHgSr3XZ-eBCsQ,3745
 diffsynth_engine/utils/download.py,sha256=w9QQjllPfTUEY371UTREU7o_vvdMY-Q2DymDel3ZEZY,6792
 diffsynth_engine/utils/env.py,sha256=k749eYt_qKGq38GocDiXfkhp8nZrowFefNVTZ8R755I,363
 diffsynth_engine/utils/flag.py,sha256=KSzjnzRe7sleNCJm8IpbJQbmBY4KNV2kDrijxi27Jek,2928
@@ -184,14 +193,14 @@ diffsynth_engine/utils/offload.py,sha256=94og79TIkxldwYUgZT3L4OVu1WBlE7gfVPvO2MR
 diffsynth_engine/utils/onnx.py,sha256=jeWUudJHnESjuiEAHyUZYUZz7dCj34O9aGjHCe8yjWo,1149
 diffsynth_engine/utils/parallel.py,sha256=OBGsAK-3ncArRyMU1lea7tbYgxSdCucQvXheL3Ssl5M,17653
 diffsynth_engine/utils/platform.py,sha256=nbpG-XHJFRmYY6u_e7IBQ9Q6GyItrIkKf3VKuBPTUpY,627
-diffsynth_engine/utils/process_group.py,sha256=P-X04a--Zb4M4kjc3DddmusrxCKqv8wiDGhXG4Al-rE,3783
+diffsynth_engine/utils/process_group.py,sha256=I9uiqoVq-Hlu694GnrvbVi7nfVJBsgCCDo3p2kjU3yo,3783
 diffsynth_engine/utils/prompt.py,sha256=YItMchoVzsG6y-LB4vzzDUWrkhKRVlt1HfVhxZjSxMQ,280
 diffsynth_engine/utils/video.py,sha256=8FCaeqIdUsWMgWI_6SO9SPynsToGcLCQAVYFTc4CDhg,2200
 diffsynth_engine/utils/memory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 diffsynth_engine/utils/memory/linear_regression.py,sha256=oW_EQEw13oPoyUrxiL8A7Ksa5AuJ2ynI2qhCbfAuZbg,3930
 diffsynth_engine/utils/memory/memory_predcit_model.py,sha256=EXprSl_zlVjgfMWNXP-iw83Ot3hyMcgYaRPv-dvyL84,3943
-diffsynth_engine-0.6.1.dev34.dist-info/licenses/LICENSE,sha256=x7aBqQuVI0IYnftgoTPI_A0I_rjdjPPQkjnU6N2nikM,11346
-diffsynth_engine-0.6.1.dev34.dist-info/METADATA,sha256=Uu-yhnydrVudp5RdK0ifk9-q4J_18zulQge4fNs24Z0,1164
-diffsynth_engine-0.6.1.dev34.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-diffsynth_engine-0.6.1.dev34.dist-info/top_level.txt,sha256=6zgbiIzEHLbhgDKRyX0uBJOV3F6VnGGBRIQvSiYYn6w,17
-diffsynth_engine-0.6.1.dev34.dist-info/RECORD,,
+diffsynth_engine-0.6.1.dev35.dist-info/licenses/LICENSE,sha256=x7aBqQuVI0IYnftgoTPI_A0I_rjdjPPQkjnU6N2nikM,11346
+diffsynth_engine-0.6.1.dev35.dist-info/METADATA,sha256=mwDiBscVZRY6rz7Mbmv4qxhlFNSFoACIu4xl0YA9lVE,1164
+diffsynth_engine-0.6.1.dev35.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+diffsynth_engine-0.6.1.dev35.dist-info/top_level.txt,sha256=6zgbiIzEHLbhgDKRyX0uBJOV3F6VnGGBRIQvSiYYn6w,17
+diffsynth_engine-0.6.1.dev35.dist-info/RECORD,,