hcpdiff 2.3.1__py3-none-any.whl → 2.4__py3-none-any.whl

hcpdiff/workflow/diffusion.py

@@ -8,6 +8,9 @@ from hcpdiff.utils import prepare_seed
 from hcpdiff.utils.net_utils import get_dtype, to_cuda
 from rainbowneko.infer import BasicAction, Actions
 from torch.cuda.amp import autocast
+from einops import rearrange, repeat
+from hcpdiff.models.compose import SDXLTextEncoder
+from diffusers import FluxTransformer2DModel, PixArtTransformer2DModel
 
 try:
     from diffusers.utils import randn_tensor
@@ -91,14 +94,15 @@ class MakeTimestepsAction(BasicAction):
             return {'timesteps':timesteps}
 
 class MakeLatentAction(BasicAction):
-    def __init__(self, N_ch=4, height=None, width=None, key_map_in=None, key_map_out=None):
+    def __init__(self, N_ch=4, height=None, width=None, patch_size=1, key_map_in=None, key_map_out=None):
         super().__init__(key_map_in, key_map_out)
         self.N_ch = N_ch
         self.height = height
         self.width = width
+        self.patch_size = patch_size
 
     def forward(self, noise_sampler:BaseSampler, vae, generator, device, dtype, bs=None, latents=None, start_timestep=None,
-                pooled_output=None, crop_coord=None, **states):
+                pooler_output=None, crop_coord=None, **states):
         if bs is None:
             if 'prompt' in states:
                 bs = len(states['prompt'])
@@ -121,34 +125,38 @@ class MakeLatentAction(BasicAction):
             # scale the initial noise by the standard deviation required by the noise_sampler
             noise_sampler.generator = generator
             latents = noise_sampler.init_noise(shape, device=device, dtype=get_dtype(dtype))
+            if self.patch_size>1:
+                latents = rearrange(latents, "b c (h ph) (w pw) -> b (c ph pw) h w", ph=self.patch_size, pw=self.patch_size)
         else:
             # image to image
             latents = latents.to(device)
+            if self.patch_size>1:
+                latents = rearrange(latents, "b c (h ph) (w pw) -> b (c ph pw) h w", ph=self.patch_size, pw=self.patch_size)
             latents, noise = noise_sampler.add_noise(latents, start_timestep)
 
-        output = {'latents':latents}
+        output = {'latents':latents, 'latent_w':shape[3], 'latent_h':shape[2], 'patch_size':self.patch_size}
 
         # SDXL inputs
-        if pooled_output is not None:
+        if pooler_output is not None:
             width, height = shape[3]*vae_scale_factor, shape[2]*vae_scale_factor
             if crop_coord is None:
                 crop_info = torch.tensor([height, width, 0, 0, height, width], dtype=torch.float)
             else:
                 crop_info = torch.tensor([height, width, *crop_coord], dtype=torch.float)
             crop_info = crop_info.to(device).repeat(bs, 1)
-            output['text_embeds'] = pooled_output[-1].to(device)
+            output['pooler_output'] = pooler_output.to(device)
 
             if 'negative_prompt' in states:
                 output['crop_info'] = torch.cat([crop_info, crop_info], dim=0)
 
         return output
 
-class DenoiseAction(BasicAction):
+class SD15DenoiseAction(BasicAction):
     def __init__(self, guidance_scale: float = 7.0, key_map_in=None, key_map_out=None):
         super().__init__(key_map_in, key_map_out)
         self.guidance_scale = guidance_scale
 
-    def forward(self, denoiser, noise_sampler: BaseSampler, t, latents, prompt_embeds, text_embeds=None, encoder_attention_mask=None, crop_info=None,
+    def forward(self, denoiser, noise_sampler: BaseSampler, t, latents, prompt_embeds, encoder_attention_mask=None,
                 cross_attention_kwargs=None, dtype='fp32', amp=None, model_offload=False, **states):
 
         if model_offload:
@@ -159,19 +167,123 @@ class DenoiseAction(BasicAction):
             latent_model_input = noise_sampler.sigma_scheduler.c_in(t)*latent_model_input
             t_in = noise_sampler.sigma_scheduler.c_noise(t)
 
-            if text_embeds is None:
-                noise_pred = denoiser(latent_model_input, t_in, prompt_embeds, encoder_attention_mask=encoder_attention_mask,
-                                  cross_attention_kwargs=cross_attention_kwargs, ).sample
-            else:
-                added_cond_kwargs = {"text_embeds":text_embeds, "time_ids":crop_info}
-                # predict the noise residual
-                noise_pred = denoiser(latent_model_input, t_in, prompt_embeds, encoder_attention_mask=encoder_attention_mask,
-                                  cross_attention_kwargs=cross_attention_kwargs, added_cond_kwargs=added_cond_kwargs).sample
+            noise_pred = denoiser(latent_model_input, t_in, prompt_embeds, encoder_attention_mask=encoder_attention_mask,
+                                cross_attention_kwargs=cross_attention_kwargs, ).sample
+            # perform guidance
+            if self.guidance_scale>1:
+                noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
+                noise_pred = noise_pred_uncond+self.guidance_scale*(noise_pred_text-noise_pred_uncond)
+
+        return {'noise_pred':noise_pred}
+
+class SDXLDenoiseAction(BasicAction):
+    def __init__(self, guidance_scale: float = 7.0, key_map_in=None, key_map_out=None):
+        super().__init__(key_map_in, key_map_out)
+        self.guidance_scale = guidance_scale
+
+    def forward(self, denoiser, noise_sampler: BaseSampler, t, latents, prompt_embeds, pooler_output=None, encoder_attention_mask=None,
+                crop_info=None, cross_attention_kwargs=None, dtype='fp32', amp=None, model_offload=False, **states):
+
+        if model_offload:
+            to_cuda(denoiser)  # to_cpu in VAE
+
+        with autocast(enabled=amp is not None, dtype=get_dtype(amp)):
+            latent_model_input = torch.cat([latents]*2) if self.guidance_scale>1 else latents
+            latent_model_input = noise_sampler.sigma_scheduler.c_in(t)*latent_model_input
+            t_in = noise_sampler.sigma_scheduler.c_noise(t)
+
+            added_cond_kwargs = {"text_embeds":pooler_output, "time_ids":crop_info}
+            # predict the noise residual
+            noise_pred = denoiser(latent_model_input, t_in, prompt_embeds, encoder_attention_mask=encoder_attention_mask,
+                                cross_attention_kwargs=cross_attention_kwargs, added_cond_kwargs=added_cond_kwargs).sample
+
+            # perform guidance
+            if self.guidance_scale>1:
+                noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
+                noise_pred = noise_pred_uncond+self.guidance_scale*(noise_pred_text-noise_pred_uncond)
+
+        return {'noise_pred':noise_pred}
+
+class PixartDenoiseAction(BasicAction):
+    def __init__(self, guidance_scale: float = 7.0, key_map_in=None, key_map_out=None):
+        super().__init__(key_map_in, key_map_out)
+        self.guidance_scale = guidance_scale
+
+    def forward(self, denoiser, noise_sampler: BaseSampler, t, latents, prompt_embeds, encoder_attention_mask=None,
+                cross_attention_kwargs=None, dtype='fp32', amp=None, model_offload=False, **states):
+
+        if model_offload:
+            to_cuda(denoiser)  # to_cpu in VAE
+
+        with autocast(enabled=amp is not None, dtype=get_dtype(amp)):
+            latent_model_input = torch.cat([latents]*2) if self.guidance_scale>1 else latents
+            latent_model_input = noise_sampler.sigma_scheduler.c_in(t)*latent_model_input
+            t_in = noise_sampler.sigma_scheduler.c_noise(t)
 
+            if t_in.dim() == 0:
+                t_in = t_in.unsqueeze(0).expand(latent_model_input.shape[0])
+            
+            noise_pred = denoiser(latent_model_input, prompt_embeds, t_in, encoder_attention_mask=encoder_attention_mask,
+                                cross_attention_kwargs=cross_attention_kwargs, ).sample
             # perform guidance
             if self.guidance_scale>1:
                 noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
                 noise_pred = noise_pred_uncond+self.guidance_scale*(noise_pred_text-noise_pred_uncond)
+        
+        # remove vars from DiT
+        noise_pred, _ = noise_pred.chunk(2, dim=1)
+
+        return {'noise_pred':noise_pred}
+
+class FluxDenoiseAction(BasicAction):
+    def __init__(self, guidance_scale: float = 7.0, true_cfg=False, key_map_in=None, key_map_out=None):
+        super().__init__(key_map_in, key_map_out)
+        self.guidance_scale = guidance_scale
+        self.true_cfg = true_cfg
+
+    def forward(self, denoiser, noise_sampler: BaseSampler, t, latents, prompt_embeds, pooler_output=None, encoder_attention_mask=None,
+                latent_w=None, latent_h=None, dtype='fp32', amp=None, model_offload=False, **states):
+
+        if model_offload:
+            to_cuda(denoiser)  # to_cpu in VAE
+
+        with autocast(enabled=amp is not None, dtype=get_dtype(amp)):
+            if self.true_cfg:
+                latent_model_input = torch.cat([latents]*2) if self.guidance_scale>1 else latents
+                latent_model_input = noise_sampler.sigma_scheduler.c_in(t)*latent_model_input
+                t_in = noise_sampler.sigma_scheduler.c_noise(t)
+                latent_model_input = rearrange(latent_model_input, "b c h w -> b (h w) c")
+
+                img_ids = torch.zeros(latent_h, latent_w, 3)
+                img_ids[..., 1] = img_ids[..., 1]+torch.arange(latent_h)[:, None]
+                img_ids[..., 2] = img_ids[..., 2]+torch.arange(latent_w)[None, :]
+                img_ids = repeat(img_ids, "h w c -> b (h w) c", b=latent_model_input.shape[0])
+
+                txt_ids = torch.zeros(prompt_embeds.shape[0], prompt_embeds.shape[1], 3)
+
+                # predict the noise residual
+                noise_pred = denoiser(latent_model_input, t_in, 1.0, pooler_output, prompt_embeds, txt_ids, img_ids).sample
+
+                # perform guidance
+                if self.guidance_scale>1:
+                    noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
+                    noise_pred = noise_pred_uncond+self.guidance_scale*(noise_pred_text-noise_pred_uncond)
+            else:
+                latent_model_input = latents
+                latent_model_input = noise_sampler.sigma_scheduler.c_in(t)*latent_model_input
+                t_in = noise_sampler.sigma_scheduler.c_noise(t)
+                latent_model_input = rearrange(latent_model_input, "b c h w -> b (h w) c")
+
+                img_ids = torch.zeros(latent_h, latent_w, 3)
+                img_ids[..., 1] = img_ids[..., 1]+torch.arange(latent_h)[:, None]
+                img_ids[..., 2] = img_ids[..., 2]+torch.arange(latent_w)[None, :]
+                img_ids = repeat(img_ids, "h w c -> b (h w) c", b=latent_model_input.shape[0])
+
+                txt_ids = torch.zeros(latent_model_input.shape[0], prompt_embeds.shape[1], 3)
+
+                # predict the noise residual
+                noise_pred = denoiser(latent_model_input, t_in, self.guidance_scale, pooler_output, prompt_embeds, txt_ids, img_ids).sample
+            noise_pred = rearrange(noise_pred, "b (h w) c -> b c h w", h=latent_h, w=latent_w)
 
         return {'noise_pred':noise_pred}
 
@@ -182,12 +294,27 @@ class SampleAction(BasicAction):
         return {'latents':latents}
 
 class DiffusionStepAction(BasicAction):
-    def __init__(self, guidance_scale: float = 7.0, key_map_in=None, key_map_out=None):
+    def __init__(self, guidance_scale: float = 7.0, denoise_action:str|BasicAction='auto', true_cfg=False, key_map_in=None, key_map_out=None):
         super().__init__(key_map_in, key_map_out)
-        self.act_noise_pred = DenoiseAction(guidance_scale)
+        if callable(denoise_action):
+            self.act_noise_pred = denoise_action(guidance_scale)
+        else:
+            self.act_noise_pred = None
+            self.true_cfg = true_cfg
+            self.guidance_scale = guidance_scale
         self.act_sample = SampleAction()
 
-    def forward(self, denoiser, noise_sampler, **states):
+    def forward(self, denoiser, noise_sampler, TE, **states):
+        if self.act_noise_pred is None:
+            if isinstance(denoiser, FluxTransformer2DModel):
+                self.act_noise_pred = FluxDenoiseAction(guidance_scale=self.guidance_scale, true_cfg=self.true_cfg)
+            elif isinstance(TE, SDXLTextEncoder):
+                self.act_noise_pred = SDXLDenoiseAction(guidance_scale=self.guidance_scale)
+            elif isinstance(denoiser, PixArtTransformer2DModel):
+                self.act_noise_pred = PixartDenoiseAction(guidance_scale=self.guidance_scale)
+            else:
+                self.act_noise_pred = SD15DenoiseAction(guidance_scale=self.guidance_scale)
+
         states = self.act_noise_pred(denoiser=denoiser, noise_sampler=noise_sampler, **states)
         states = self.act_sample(**states)
         return states

hcpdiff/workflow/text.py

@@ -2,7 +2,7 @@ from typing import List, Union
 
 import torch
 from hcpdiff.models import TokenizerHook
-from hcpdiff.models.compose import ComposeTEEXHook, ComposeEmbPTHook
+from hcpdiff.models.compose import ComposeTEEXHook, ComposeEmbPTHook, ComposeTokenizer
 from hcpdiff.utils import pad_attn_bias
 from hcpdiff.utils.net_utils import get_dtype, to_cpu, to_cuda
 from rainbowneko.infer import BasicAction
@@ -42,13 +42,30 @@ class TextEncodeAction(BasicAction):
         super().__init__(key_map_in, key_map_out)
         if isinstance(prompt, str) and bs is not None:
             prompt = [prompt]*bs
-            negative_prompt = [negative_prompt]*bs
+            if negative_prompt is not None:
+                negative_prompt = [negative_prompt]*bs
 
         self.prompt = prompt
         self.negative_prompt = negative_prompt
         self.bs = bs
 
-    def forward(self, te_hook, TE, dtype: str, device, amp=None, prompt=None, negative_prompt=None, model_offload=False, **states):
+    def encode_prompt_to_emb(self, tokenizer, TE, te_hook, prompt, device):
+        token_info = ComposeTokenizer.tokenize_ex(tokenizer, prompt, truncation=True, padding="max_length",
+                                                  return_tensors="pt", device=device)
+        if te_hook.use_attention_mask:
+            attention_mask = token_info.get('attention_mask', None)
+        else:
+            attention_mask = None
+        token_info['attention_mask'] = attention_mask
+        input_ids = token_info.pop('input_ids') # for TEEXHook
+        prompt_embeds, pooler_output = TE(
+            input_ids,
+            **token_info,
+            output_hidden_states=True,
+        )
+        return prompt_embeds, pooler_output, attention_mask
+
+    def forward(self, te_hook, tokenizer, TE, dtype: str, device, amp=None, prompt=None, negative_prompt=None, model_offload=False, **states):
         prompt = prompt or self.prompt
         negative_prompt = negative_prompt or self.negative_prompt
 
@@ -56,7 +73,10 @@ class TextEncodeAction(BasicAction):
             to_cuda(TE)
 
         with autocast(enabled=amp is not None, dtype=get_dtype(amp)):
-            emb, pooled_output, attention_mask = te_hook.encode_prompt_to_emb(negative_prompt+prompt)
+            if negative_prompt is None:
+                emb, pooler_output, attention_mask = self.encode_prompt_to_emb(tokenizer, TE, te_hook, prompt, device)
+            else:
+                emb, pooler_output, attention_mask = self.encode_prompt_to_emb(tokenizer, TE, te_hook, negative_prompt+prompt, device)
             if attention_mask is not None:
                 emb, attention_mask = pad_attn_bias(emb, attention_mask)
 
@@ -64,12 +84,12 @@ class TextEncodeAction(BasicAction):
             to_cpu(TE)
 
         if not isinstance(te_hook, ComposeTEEXHook):
-            pooled_output = None
+            pooler_output = None
         return {'prompt':prompt, 'negative_prompt':negative_prompt, 'prompt_embeds':emb, 'encoder_attention_mask':attention_mask,
-            'pooled_output':pooled_output}
+            'pooler_output':pooler_output}
 
 class AttnMultTextEncodeAction(TextEncodeAction):
-    def forward(self, te_hook, token_ex, TE, dtype: str, device, amp=None, prompt=None, negative_prompt=None, model_offload=False, **states):
+    def forward(self, te_hook, tokenizer, token_ex, TE, dtype: str, device, amp=None, prompt=None, negative_prompt=None, model_offload=False, **states):
         prompt = prompt or self.prompt
         negative_prompt = negative_prompt or self.negative_prompt
 
@@ -81,18 +101,29 @@ class AttnMultTextEncodeAction(TextEncodeAction):
         if model_offload:
             to_cuda(TE)
 
-        mult_p, clean_text_p = token_ex.parse_attn_mult(prompt)
-        mult_n, clean_text_n = token_ex.parse_attn_mult(negative_prompt)
-        with autocast(enabled=amp is not None, dtype=get_dtype(amp)):
-            emb, pooled_output, attention_mask = te_hook.encode_prompt_to_emb(clean_text_n+clean_text_p)
-            if attention_mask is not None:
-                emb, attention_mask = pad_attn_bias(emb, attention_mask)
-            emb_n, emb_p = emb.chunk(2)
-        emb_p = te_hook.mult_attn(emb_p, mult_p)
-        emb_n = te_hook.mult_attn(emb_n, mult_n)
+        if negative_prompt is None:
+            mult_p, clean_text_p = token_ex.parse_attn_mult(prompt)
+            with autocast(enabled=amp is not None, dtype=get_dtype(amp)):
+                emb, pooler_output, attention_mask = self.encode_prompt_to_emb(tokenizer, TE, te_hook, clean_text_p, device)
+                if attention_mask is not None:
+                    emb, attention_mask = pad_attn_bias(emb, attention_mask)
+            emb = te_hook.mult_attn(emb, mult_p)
+        else:
+            mult_p, clean_text_p = token_ex.parse_attn_mult(prompt)
+            mult_n, clean_text_n = token_ex.parse_attn_mult(negative_prompt)
+            with autocast(enabled=amp is not None, dtype=get_dtype(amp)):
+                emb, pooler_output, attention_mask =  self.encode_prompt_to_emb(tokenizer, TE, te_hook, clean_text_n+clean_text_p, device)
+                if attention_mask is not None:
+                    emb, attention_mask = pad_attn_bias(emb, attention_mask)
+                emb_n, emb_p = emb.chunk(2)
+            emb_p = te_hook.mult_attn(emb_p, mult_p)
+            emb_n = te_hook.mult_attn(emb_n, mult_n)
 
         if model_offload:
             to_cpu(TE)
 
-        return {'prompt':list(clean_text_p), 'negative_prompt':list(clean_text_n), 'prompt_embeds':torch.cat([emb_n, emb_p], dim=0),
-            'encoder_attention_mask':attention_mask, 'pooled_output':pooled_output}
+        if negative_prompt is None:
+            return {'prompt':list(clean_text_p), 'prompt_embeds':emb, 'encoder_attention_mask':attention_mask, 'pooler_output':pooler_output}
+        else:
+            return {'prompt':list(clean_text_p), 'negative_prompt':list(clean_text_n), 'prompt_embeds':torch.cat([emb_n, emb_p], dim=0),
+            'encoder_attention_mask':attention_mask, 'pooler_output':pooler_output}

hcpdiff/workflow/vae.py

@@ -41,7 +41,11 @@ class EncodeAction(BasicAction):
             else:
                 init_latents = vae.encode(image).latent_dist.sample(generator)
 
-            init_latents = vae.config.scaling_factor*init_latents.to(dtype=get_dtype(dtype))
+            init_latents = init_latents.to(dtype=get_dtype(dtype))
+            if shift_factor := getattr(vae.config, 'shift_factor', None) is not None:
+                init_latents = (init_latents-shift_factor)*vae.config.scaling_factor
+            else:
+                init_latents = init_latents*vae.config.scaling_factor
             if model_offload:
                 to_cpu(vae)
         return {'latents':init_latents}
@@ -63,7 +67,11 @@ class DecodeAction(BasicAction):
             torch.cuda.synchronize()
             to_cuda(vae)
         latents = latents.to(dtype=vae.dtype)
-        image = vae.decode(latents/vae.config.scaling_factor, return_dict=False)[0]
+        if shift_factor := getattr(vae.config, 'shift_factor', None) is not None:
+            latents = latents/vae.config.scaling_factor + shift_factor
+        else:
+            latents = latents/vae.config.scaling_factor
+        image = vae.decode(latents, return_dict=False)[0]
         if model_offload:
             to_cpu(vae)
 

{hcpdiff-2.3.1.dist-info → hcpdiff-2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hcpdiff
-Version: 2.3.1
+Version: 2.4
 Summary: A universal Diffusion toolbox
 Home-page: https://github.com/IrisRainbowNeko/HCP-Diffusion
 Author: Ziyi Dong

{hcpdiff-2.3.1.dist-info → hcpdiff-2.4.dist-info}/RECORD

@@ -3,22 +3,22 @@ hcpdiff/train_colo.py,sha256=EsuNSzLBvGTZWU_LEk0JpP-F5eNW0lwkawIRAX38jmE,9250
 hcpdiff/trainer_ac.py,sha256=-owV-3_bvPxuQsZS2WaajBDh58HpftRtnx0GJkswqaY,2787
 hcpdiff/trainer_ac_single.py,sha256=zyZVrutLUbIJYW1HzUnQ_RnmIcDhbC7M_CT833PJH5w,993
 hcpdiff/trainer_deepspeed.py,sha256=7lGsiAstWuIlmhRMwWTcJCkoxzUaakVxBngKDnJdSJk,1947
-hcpdiff/ckpt_manager/__init__.py,sha256=r_sgjZWCLtdJrRkqqU6aPdfubXSYfPh2Z_Vf_XpZXXs,240
+hcpdiff/ckpt_manager/__init__.py,sha256=OCotG2Q4q3n4ZpN6UfY-j-Lg4VOAvtLnb0xygkkqZm8,280
 hcpdiff/ckpt_manager/ckpt.py,sha256=2A093lT03M1ZsJIMWl376V165eh0TZwOgiGrz3LM73Q,1248
 hcpdiff/ckpt_manager/loader.py,sha256=6iZDUj-Vfc5T9eGdWfFMQw4n1GqyLqaLBolgAtgqPq8,3640
-hcpdiff/ckpt_manager/format/__init__.py,sha256=a3cdKkOTDgdVbDQwSC4mlxOigjX2hBvRb5_X7E3TQWs,237
-hcpdiff/ckpt_manager/format/diffusers.py,sha256=qhGbrKAaeLyjFzY-Lj4sL1THHFNrta41JGGMoXT-bCE,3761
-hcpdiff/ckpt_manager/format/emb.py,sha256=FrqfTfJ8H7f0Zw17NTWCP2AJtpsJI5oXR5IAd4NekhU,680
-hcpdiff/ckpt_manager/format/lora_webui.py,sha256=4y_T9RdmFTxWzsXd8guNjCiukmyILa5j4MPrhVIL4Qk,10017
-hcpdiff/ckpt_manager/format/sd_single.py,sha256=4DZLAl1RNC_nPxuW-lmrBlIMFUhpSTa7HGHgu7Yx8qk,2322
+hcpdiff/ckpt_manager/format/__init__.py,sha256=9d9NOY1XRDGlebOiQpOnpQw14uPHZyL3-6Cvkc8hYZY,277
+hcpdiff/ckpt_manager/format/diffusers.py,sha256=VKXI2i4whrIaHMOFMzA8UqB5ytXOv6WMgEyU9EkDW5Y,5008
+hcpdiff/ckpt_manager/format/emb.py,sha256=jC-PR47y-TLn4xMkrujlXluGiW-tcUIhQjKZ_G33gUc,899
+hcpdiff/ckpt_manager/format/lora_webui.py,sha256=9pBesgzifInW8YnzdzmEbyrClyHt-zmkzla7kK4YrBg,10015
+hcpdiff/ckpt_manager/format/sd_single.py,sha256=gqN0NqrsxaYMAspdl48KEWtzGz_yxbxxfC6LJapbHfs,3598
 hcpdiff/data/__init__.py,sha256=ZFKtanOoMo3G3eKUJPhysnHXnr8BNARERkcMB6B897U,292
 hcpdiff/data/dataset.py,sha256=1k4GldW13eVyqK_9hrQniqr3_XYAapnWF7iXl_1GXGg,877
 hcpdiff/data/cache/__init__.py,sha256=ToCmokYH6DghlSwm7HJFirPRIWJ0LkgzqVOYlgoAkQw,25
-hcpdiff/data/cache/vae.py,sha256=gB89zs4CdNlvukDXhVYU9QZrY6VTFUWfzjeF2psNQ50,4070
+hcpdiff/data/cache/vae.py,sha256=_Vkx4AXB17hgs5Rgy9NbytMbcNu0pHMFH5mreeNjKxk,4572
 hcpdiff/data/handler/__init__.py,sha256=G8ZTQF91ilkTRmUoWdmAissTSZ7fvNUpm_hBYmXKTtk,258
 hcpdiff/data/handler/controlnet.py,sha256=bRDMD9BP8-VaG5VrxzvcFKfkqeTbChNfrJSZ3vXbQgY,658
 hcpdiff/data/handler/diffusion.py,sha256=S-_7o5Z1tm6LmRZVZs21rbJC7iUoq0tHOsSjKK6geVk,4156
-hcpdiff/data/handler/text.py,sha256=gOzqB2oEkEUbiuy0kZWduo0c-w4Buu60KI6q6Nyl3aM,4208
+hcpdiff/data/handler/text.py,sha256=I_dqFf1gKwRsNdBCv8dvAR16Do8HwOgwVLt4iH8n0bo,4331
 hcpdiff/data/source/__init__.py,sha256=265M8qfWNUE4SKX0pdXhLYjCnCuae5YE4bfZpO-ydXc,187
 hcpdiff/data/source/folder_class.py,sha256=bs4qPMTzwcnT6ZFlT3tpi9sclsRF9a2MBA1pQD-9EYs,961
 hcpdiff/data/source/text.py,sha256=VgI5Ouq986Yy1jwD2fZ9iBlsRciPCeARZmOPEZIcaQY,1468
@@ -28,57 +28,63 @@ hcpdiff/diffusion/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU
 hcpdiff/diffusion/noise/__init__.py,sha256=D83EZ6bnc6Ucu4AZwE6rpmXCtwYfHHumeVq97brbnIE,47
 hcpdiff/diffusion/noise/pyramid_noise.py,sha256=KbpyMT1BHNIaAa7g5eECDkTttOMoMWVFmbP-ekBsuEY,1693
 hcpdiff/diffusion/sampler/VP.py,sha256=r0Q_RROEIeNNw93XrOD5htW78rfuoSxy1WBQEoQL83s,958
-hcpdiff/diffusion/sampler/__init__.py,sha256=Lrwg1us8qo943T7mdIXFDRXfKvnLhrzwmi6DrIKIiUA,135
-hcpdiff/diffusion/sampler/base.py,sha256=UbE_AmtvLg-Hr2bkYz8PvNWB63tvtacUvCIDm_W6opA,5484
-hcpdiff/diffusion/sampler/diffusers.py,sha256=wIMs8n3kdci1On0FUCV0si324ZE9zeRw_CxaHP8rdcs,2586
+hcpdiff/diffusion/sampler/__init__.py,sha256=8UmSOxcFzdYnO9hkMzWx4V09ysx5RKDnf2sVYlZEM9w,156
+hcpdiff/diffusion/sampler/base.py,sha256=HhscR81Qq_m4yfnhGEDPkvxb6tJozlbT8YuTxku0kZQ,5891
+hcpdiff/diffusion/sampler/diffusers.py,sha256=-A2vbKM-CjbE4CS77jroeNhaSm8LqNsWdvYUPoDZzTM,2640
 hcpdiff/diffusion/sampler/sigma_scheduler/__init__.py,sha256=eiSmMBkXI_LfxnNrXj5XptcF0dGcPas--vWvqhFGlv8,273
-hcpdiff/diffusion/sampler/sigma_scheduler/base.py,sha256=UT4tbjFf80KYfU08y0hJf8h_Cl80a5MUhK5FsKLsqbY,2521
-hcpdiff/diffusion/sampler/sigma_scheduler/ddpm.py,sha256=SA8lXT6lucJot_rpJ84Wz-_uc5dXfb2QPoQgJHSKOj4,12999
-hcpdiff/diffusion/sampler/sigma_scheduler/edm.py,sha256=m1YlIyn61zfDjxLMcHvWs0nzULbHgXeB7WGKmTiaGSU,4127
-hcpdiff/diffusion/sampler/sigma_scheduler/flow.py,sha256=FtWpesUtSmFuiIGkrrVhYJweB7INZiw0atC64tc0Nk4,2020
+hcpdiff/diffusion/sampler/sigma_scheduler/base.py,sha256=_cAfak2M3CMdH4EK6AYKPbKA3ccRTDyNJw9NjfXBEOM,2210
+hcpdiff/diffusion/sampler/sigma_scheduler/ddpm.py,sha256=PBh2LFkRF5mrmedHvEHh8vATnIMU2gIoi3IlUEheaLY,13045
+hcpdiff/diffusion/sampler/sigma_scheduler/edm.py,sha256=cQuNj8jk4r3TDEN86i_tLYHypO3QFUPpVZMaAGVr3dA,4131
+hcpdiff/diffusion/sampler/sigma_scheduler/flow.py,sha256=1edTaTiM02ogV1lAbnI4e2gc3QUaNgl8RWwYQm6vf2s,2023
 hcpdiff/diffusion/sampler/sigma_scheduler/zero_terminal.py,sha256=CCqQLkGo4omkxzFovYdZQzdZVwIxK3PiOitZFww8MHs,859
-hcpdiff/easy/__init__.py,sha256=-emoyCOZlLCu3KNMI8L4qapUEtEYFSoiGU6-rKv1at4,149
-hcpdiff/easy/sampler.py,sha256=dQSBkeGh71O0DAmZLhTHTbk1bY7XzyUCeW1oJO14A4I,1250
+hcpdiff/diffusion/sampler/timer/__init__.py,sha256=QNmmF6dwMWQM16mRYXDq0FY7h5RiQ_tnM76PMnZnH4E,108
+hcpdiff/diffusion/sampler/timer/base.py,sha256=CgJ4aqG9jzHrlRzqQRJUOq95Cait_mXYICCIHA_OO64,872
+hcpdiff/diffusion/sampler/timer/shift.py,sha256=v2nHj6Z5bfzzVH76ypfEgK1EDDf0Lp9lfJSRCadSuwU,1735
+hcpdiff/easy/__init__.py,sha256=JT-dbN4e3iG3zHT2p9_TaesTPDwvDuj9PNFaPEhjxjU,208
+hcpdiff/easy/sampler.py,sha256=5O01VRz-bYJfzBIqRsD3vxE3AbVwh3zKzjjFXzRX9-E,1438
 hcpdiff/easy/cfg/__init__.py,sha256=SxHMWG6T2CXhX3dP0xizSMd9vFWPaZQDc4Gj4CF__yQ,253
-hcpdiff/easy/cfg/sd15_train.py,sha256=NtgsQLg1sd5JFmHU4nqMPOrvP7zmwo2x0MCspjVNQEY,7000
+hcpdiff/easy/cfg/sd15_train.py,sha256=L9bNWM87T1DIZpWetwK0gwPIWL39JoNOovDCxb7cDiw,6967
 hcpdiff/easy/cfg/sdxl_train.py,sha256=rVLLKVMKB_PHuum3dKQcBqL0uR8QhzmdRllM-pYnbK4,4534
 hcpdiff/easy/cfg/t2i.py,sha256=SnjFjZAKd9orjJr3RW5_N2_EIlW2Ree7JMvdNUAR9gc,9507
-hcpdiff/easy/model/__init__.py,sha256=CA-7r3R2Jgweekk1XNByFYttLolbWyUV2bCnXygcD8w,133
+hcpdiff/easy/model/__init__.py,sha256=UukTqyidx-W2n2eiG4mUQBa0Sziv7gYmuBPx1twvE90,170
 hcpdiff/easy/model/cnet.py,sha256=m0NTH9V1kLzb5GybwBrSNT0KvTcRpPfGkzUeMz9jZZQ,1084
-hcpdiff/easy/model/loader.py,sha256=Tdx-lhQEYf2NYjVM1A5B8x6ZZpJKcXUkFIPIbr7h7XM,3456
+hcpdiff/easy/model/loader.py,sha256=nm06hPqtQuIwpa6GnygG1CBgmywhmB5mcACRcDPa51U,4355
 hcpdiff/evaluate/__init__.py,sha256=qWxV0D8Ho5uBj2YbaC_QFDnT49PSKPfh44m4ivkNbMM,108
 hcpdiff/evaluate/evaluator.py,sha256=9BZQBeC-N7p-ICx6Giw9v-2Tb9volMTDmeDfhj0nXJ0,2940
 hcpdiff/evaluate/previewer.py,sha256=-vE0YXVfos70CQMo9ZInw7xu3d88DlTfVLs4BzzkxfM,3140
 hcpdiff/evaluate/metrics/__init__.py,sha256=vE0nSvBtDBu9SomANvWcm2UHX56PhCYwhgrcmm_mKyo,39
 hcpdiff/evaluate/metrics/clip_score.py,sha256=rQgweu5QcqW3fPI3EXcNbrH2QCcSAekE3lpYk45P2M4,900
-hcpdiff/loss/__init__.py,sha256=2dwPczSiv3rB5fzOeYbl5ZHpMU-qXOQlXeOiXdxcxwM,173
+hcpdiff/loss/__init__.py,sha256=wlWpg4a2ev7JXsv52MwJmWCduvq011IoSTmABJ_XM2M,230
 hcpdiff/loss/base.py,sha256=Vvpm-KZGH4n-gYIlnVAtPl1B799c7v0dJXJ5BBh3yO0,1112
+hcpdiff/loss/charbonnier.py,sha256=Qvjj9bznJEBn_NFPbPsVf9jzawOcfVvien54bMS2UGc,461
 hcpdiff/loss/gw.py,sha256=0yi1kozuII3xZA6FnjOhINtvScWt1MyBZLBtMKmgojM,1224
 hcpdiff/loss/ssim.py,sha256=YofadvBkc6sklxBUx1p3ADw5OHOZPK3kaHz8FH5a6m4,1281
-hcpdiff/loss/vlb.py,sha256=s78iBnXUiDWfGf7mYmhUnHqxqea5gSByKOoqBrX6bzU,3222
-hcpdiff/loss/weighting.py,sha256=9qzMnvCb6b5qx0p08GDSlkxmYEqQcNt79XdRBvfHmiI,2914
-hcpdiff/models/__init__.py,sha256=eQS7DPiGLiE1MFRkZj_17IY3IsfDUVcYpcOmhHb5B9o,472
-hcpdiff/models/cfg_context.py,sha256=e2B3K1KwJhzbD6xdJUOyNtl_XgQ0296XI3FHw3gvZF4,1502
+hcpdiff/loss/vlb.py,sha256=NqkhzGM3g_67nmpg18I0W_KC8X6YvKSZyHfH9C14OCg,3256
+hcpdiff/loss/weighting.py,sha256=qJvp895qwT6H6_x1IhxkHWMYPjqM5peiyciB634LREI,3668
+hcpdiff/models/__init__.py,sha256=__LnS75jcEmJ0Y_b5N6zsDI9CMxByBNKNuPrcUXRRwo,485
+hcpdiff/models/cfg_context.py,sha256=FePMdvzDfH4Xo6aYVqR2UTzU7t_MhAKhnSrGWlua1Ts,1553
 hcpdiff/models/container.py,sha256=z3p5TmQhxdzXSIfofz55_bmEhSsgUJsy1o9EcDs8Oeo,696
 hcpdiff/models/controlnet.py,sha256=VIkUzJCVpCqqQOtRSLQPfbcDy9CsXutxLeZB6PdZfA0,7809
 hcpdiff/models/lora_base.py,sha256=LGwBD9KP6qf4pgTx24i5-JLo4rDBQ6jFfterQKBjTbE,6758
 hcpdiff/models/lora_base_patch.py,sha256=Tdb_b3TN_K-04nlUvcfBh6flPcbL9M4iP7jOVyb1jXQ,7271
 hcpdiff/models/lora_layers.py,sha256=O9W_Ue71lHj7Y_GbpioF4Hc3h2-z_zOqck93VYUra6s,7777
 hcpdiff/models/lora_layers_patch.py,sha256=GYFYsJD2VSLZfdnLma9CmQEHz09HROFJcc4wc_gs9f0,8198
-hcpdiff/models/text_emb_ex.py,sha256=O0XZqid01OrB0dHY7hCiBvdU2026SvZ38yfQaF2TWrs,8018
-hcpdiff/models/textencoder_ex.py,sha256=JrTQ30Avx8tPbdr-Q6K5BvEWCEdsu8Z7eSOzMqpUuzg,8270
+hcpdiff/models/text_emb_ex.py,sha256=HQAwXf-3CXH27ehOjCNRMk26Sp7hbj4rU8ewWP_GWa8,8116
+hcpdiff/models/textencoder_ex.py,sha256=vQNFDmmAfXmF9cGbqMKYQhoYrrdwq39PVb0mubEkTLs,6926
 hcpdiff/models/tokenizer_ex.py,sha256=zKUn4BY7b3yXwK9PWkZtQKJPyKYwUc07E-hwB9NQybs,2446
-hcpdiff/models/compose/__init__.py,sha256=lTNFTGg5csqvUuys22RqgjmWlk_7Okw6ZTsnTi1pqCg,217
-hcpdiff/models/compose/compose_hook.py,sha256=FfDSfn5FuLFGM80HMUwiUopy1P4xDbvKSBDuA6QK2So,6112
-hcpdiff/models/compose/compose_textencoder.py,sha256=tiFoStKOIEH9YzsZQrLki4gra18kMy3wSzSUrVQG1sk,6607
-hcpdiff/models/compose/compose_tokenizer.py,sha256=g3l0pOFv6p7Iigxm6Pqt_iTUXBlO1_SWAQOt0m54IoE,3033
-hcpdiff/models/compose/sdxl_composer.py,sha256=NtMGaFGZTfKsPJSVi2yT-UM6K1WKWtk99XxVmTcKlk8,2164
-hcpdiff/models/wrapper/__init__.py,sha256=HbGQmFnfccr-dtvZKjEv-pmR4cCnF4fwGLKS3tuG_OY,135
-hcpdiff/models/wrapper/pixart.py,sha256=nRUvHSHn4TYg_smC0xpeW-GtUgXss-MuaVPTHpMozDE,1147
-hcpdiff/models/wrapper/sd.py,sha256=EywmVU2QzR74M_4eH_uXVW8HJNauyjwcZPU7rRAQ7eI,11666
+hcpdiff/models/compose/__init__.py,sha256=c2Zsk8ge6T5iOOl-8HRKtDoSpdQ3fS88mDiYZC3VpHE,257
+hcpdiff/models/compose/compose_hook.py,sha256=rU6PIhyEVjnDQlw5NOB5QdydNlSLe60CnilUn_NpxH4,6352
+hcpdiff/models/compose/compose_textencoder.py,sha256=7rPplxzs9xXxYqpHhTp-qX30nAXtgb6ZpClFLDVouvk,7409
+hcpdiff/models/compose/compose_tokenizer.py,sha256=AogUrqwmztAX21oyVfW8j5fcPPiGDZMT1_9wPQcxBMc,4572
+hcpdiff/models/compose/flux.py,sha256=Fcg-zzpsWbNdOB0VsJAoicMK62l2uCWugFoq_uIxtzY,3632
+hcpdiff/models/compose/sdxl.py,sha256=cgR5BplUSPPud_nG0dH6LT3SoWu9ypLVXLMgzcnvyaI,4522
+hcpdiff/models/wrapper/__init__.py,sha256=ZFQ4CqJvSA_saKmI8eKgqvT6pIKtG52gonE4ZzLOkok,165
+hcpdiff/models/wrapper/flux.py,sha256=Zqm-Qnz-Jrtwd1h5sPfctVIp6cnSQViFvGnSw0UOn6E,4567
+hcpdiff/models/wrapper/pixart.py,sha256=zsqA3soCdGyTxAO3u9NiQdqO8rUPsrtXiAh8E-ziMd4,1861
+hcpdiff/models/wrapper/sd.py,sha256=O49ziLrHeGVaVEXGcgZ4zkRNSnARiLeZWmPOW8ZzIU0,12080
 hcpdiff/models/wrapper/utils.py,sha256=NyebMoAPnrgcTHbiIocSD-eGdGdD-V1G_TQuWsRWufw,665
 hcpdiff/parser/__init__.py,sha256=-2dDZ2Ii4zoGQqDTme94q4PpJbBiV6HS5BsDASz4Xbo,33
-hcpdiff/parser/embpt.py,sha256=LgwZ0f0tLn3DrTo5ZpSCsZcA5330UpiW_sK96yEPmOM,1307
+hcpdiff/parser/embpt.py,sha256=-AP2wn8FkxryzzMAOERAt9vdd8ZEWD1tNUYVPAghaEM,1419
 hcpdiff/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hcpdiff/tools/convert_caption_txt2json.py,sha256=tbBgIphJWvXUoXjtwsnLX2w9IZEY3jTgxbTvUMgukbM,945
 hcpdiff/tools/convert_old_lora.py,sha256=yIP9RGcyQbwT2NNAZtTLgBXs6XJOHRvoHQep0SdqDho,453
@@ -94,26 +100,24 @@ hcpdiff/tools/save_model.py,sha256=gbfYi_EfEBZEUcDjle6MDHA19sQWY0zA8_y_LMzHQ7M,4
 hcpdiff/tools/sd2diffusers.py,sha256=vB6OnBLw60sJkdpVZcYEPtKAZW1h8ErbSGSRq0uAiIk,16855
 hcpdiff/utils/__init__.py,sha256=28K9Ui0uur-vHuUdlSyIBYijgu2b7rGOPXN2ogJu1z8,82
 hcpdiff/utils/colo_utils.py,sha256=JyLUvVnISa48CnryNLrgVxMo-jxu2UhBq70eYPrkjuI,837
-hcpdiff/utils/inpaint_pipe.py,sha256=CRy1MUlPmHifCAbZnKOP0qbLp2grn7ZbVeaB2qIA4ig,42862
-hcpdiff/utils/net_utils.py,sha256=gdwLYDNKV2t3SP0jBIO3d0HtY6E7jRaf_rmPT8gKZZE,9762
-hcpdiff/utils/pipe_hook.py,sha256=-UDX3FtZGl-bxSk13gdbPXc1OvtbCcpk_fvKxLQo3Ag,31987
+hcpdiff/utils/net_utils.py,sha256=dL3Q9I8X7xAcssQomWAvapwmTXCffWQ80vcAVUCHOt4,10211
 hcpdiff/utils/torch_utils.py,sha256=gBZCcDKZc0NGDQx6QeHuQePoZ82kQRhaL7oEdZIYGvU,573
 hcpdiff/utils/utils.py,sha256=hZnZP1IETgVpScxES0yIuRfc34TnzvAqmgOTK_56ssw,4976
-hcpdiff/workflow/__init__.py,sha256=i5s7QXo6wK9607KL0KTW4suE1c-HGJ5_EgnCdVLl3WM,885
-hcpdiff/workflow/diffusion.py,sha256=hKefBrVP6-025MhdrKOQMUhHxLaGqjpUKhR6WahYwh0,9549
+hcpdiff/workflow/__init__.py,sha256=Ve_ZZZVKEplR5SDRq0yRlrT_DHSxRtpESnQSgCZ1qR0,948
+hcpdiff/workflow/diffusion.py,sha256=oEnnc8tnITXXko2Fb6ahDg7FbuKa8lZr33JWecCznPM,16535
 hcpdiff/workflow/fast.py,sha256=kZt7bKrvpFInSn7GzbkTkpoCSM0Z6IbDjgaDvcbFYf8,1024
 hcpdiff/workflow/flow.py,sha256=FFbFFOAXT4c31L5bHBEB_qeVGuBQDLYhq8kTD1chGNo,2548
 hcpdiff/workflow/io.py,sha256=4oiE_PS3sOVYT8M6PDwvT5h9XzoKDMQR0n_4-Ktttys,3284
 hcpdiff/workflow/model.py,sha256=1gj5yOTefYTnGXVR6JPAfxIwuB69YwN6E-BontRcuyQ,2913
-hcpdiff/workflow/text.py,sha256=XQvN4zzK7VaGxy4FDgSDeWh2jjk7UZU24moeRKAWXRE,4608
+hcpdiff/workflow/text.py,sha256=vz8zAA6qcYOBfvak6kM2m2KaLjiaaSPgVWhrPQtko0I,6402
 hcpdiff/workflow/utils.py,sha256=xojaMG4lHsymslc8df5uiVXmmBVWpn_Phqka8qzJEWw,2226
-hcpdiff/workflow/vae.py,sha256=cingDPkIOc4qGpOwwhXJK4EQbGoIxO583pm6gGov5t8,3118
+hcpdiff/workflow/vae.py,sha256=LOvGFm6xt1abGOh8UezloXD1pMhYkv7S0vQUE4HojGo,3548
 hcpdiff/workflow/daam/__init__.py,sha256=ySIDaxloN-D3qM7OuVaG1BR3D-CibDoXYpoTgw0zUhU,59
 hcpdiff/workflow/daam/act.py,sha256=tHbsFWTYYU4bvcZOo1Bpi_z6ofpJatRYccl4vvf8wIA,2756
 hcpdiff/workflow/daam/hook.py,sha256=z9f9mBjKW21xuUZ-iQxQ0HbWOBXtZrisFB0VNMq6d0U,4383
-hcpdiff-2.3.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-hcpdiff-2.3.1.dist-info/METADATA,sha256=zaJHhKQiezDTvyv-IIoRHf4VCv0z2gU9fq0sVi9XhTg,10323
-hcpdiff-2.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-hcpdiff-2.3.1.dist-info/entry_points.txt,sha256=_4VRsEsEWOhHfzBDu9bx8Wh_S8Wi4ZTHpI0n6rU0J-I,258
-hcpdiff-2.3.1.dist-info/top_level.txt,sha256=shyf78x-HVgykYpsmY22mKG0xIc7Qk30fDMdavdYWQ8,8
-hcpdiff-2.3.1.dist-info/RECORD,,
+hcpdiff-2.4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+hcpdiff-2.4.dist-info/METADATA,sha256=AM8nFWpSpgB0EWNhp40nh7a2G_qHS0We8sKj_ihct7w,10321
+hcpdiff-2.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+hcpdiff-2.4.dist-info/entry_points.txt,sha256=_4VRsEsEWOhHfzBDu9bx8Wh_S8Wi4ZTHpI0n6rU0J-I,258
+hcpdiff-2.4.dist-info/top_level.txt,sha256=shyf78x-HVgykYpsmY22mKG0xIc7Qk30fDMdavdYWQ8,8
+hcpdiff-2.4.dist-info/RECORD,,

hcpdiff/models/compose/sdxl_composer.py

@@ -1,39 +0,0 @@
-from .compose_textencoder import ComposeTextEncoder
-from .compose_tokenizer import ComposeTokenizer
-from transformers import CLIPTextModel, AutoTokenizer, CLIPTextModelWithProjection
-from typing import Optional, Union, Tuple
-import torch
-from transformers.modeling_outputs import BaseModelOutputWithPooling
-
-class CLIPTextModelWithProjection_Align(CLIPTextModelWithProjection):
-    # fxxk the transformers!
-    def forward(
-        self,
-        input_ids: Optional[torch.Tensor] = None,
-        attention_mask: Optional[torch.Tensor] = None,
-        position_ids: Optional[torch.Tensor] = None,
-        output_attentions: Optional[bool] = None,
-        output_hidden_states: Optional[bool] = None,
-        return_dict: Optional[bool] = None,
-    ) -> Union[Tuple, BaseModelOutputWithPooling]:
-        text_outputs = super().forward(input_ids, attention_mask, position_ids, output_attentions, output_hidden_states, return_dict)
-        return BaseModelOutputWithPooling(
-            last_hidden_state=text_outputs.last_hidden_state,
-            pooler_output=text_outputs.text_embeds,
-            hidden_states=text_outputs.hidden_states,
-            attentions=text_outputs.attentions,
-        )
-
-class SDXLTextEncoder(ComposeTextEncoder):
-    @classmethod
-    def from_pretrained(cls, pretrained_model_name_or_path: str, *args, subfolder=None, revision:str=None, **kwargs):
-        clip_L = CLIPTextModel.from_pretrained(pretrained_model_name_or_path, subfolder='text_encoder', **kwargs)
-        clip_bigG = CLIPTextModelWithProjection_Align.from_pretrained(pretrained_model_name_or_path, subfolder='text_encoder_2', **kwargs)
-        return cls([('clip_L', clip_L), ('clip_bigG', clip_bigG)])
-
-class SDXLTokenizer(ComposeTokenizer):
-    @classmethod
-    def from_pretrained(cls, pretrained_model_name_or_path: str, *args, subfolder=None, revision:str=None, **kwargs):
-        clip_L = AutoTokenizer.from_pretrained(pretrained_model_name_or_path, subfolder='tokenizer', **kwargs)
-        clip_bigG = AutoTokenizer.from_pretrained(pretrained_model_name_or_path, subfolder='tokenizer_2', **kwargs)
-        return cls([('clip_L', clip_L), ('clip_bigG', clip_bigG)])