Upload src/SubjectGeniusTransformer2DModel.py with huggingface_hub

src/SubjectGeniusTransformer2DModel.py

@@ -0,0 +1,196 @@
+import copy
+from diffusers.configuration_utils import register_to_config
+from typing import Any, Dict, Optional, Union, List, Tuple
+import numpy as np
+import torch
+from diffusers.models.transformers.transformer_flux import (
+    FluxTransformer2DModel,
+    Transformer2DModelOutput,
+)
+from diffusers.utils import unscale_lora_layers,is_torch_version,USE_PEFT_BACKEND,scale_lora_layers,logging
+from .lora_switching_module import enable_lora, module_active_adapters
+from .SubjectGeniusTransformerBlock import block_forward,single_block_forward
+
+logger = logging.get_logger(__name__)
+class SubjectGeniusTransformer2DModel(FluxTransformer2DModel):
+    @register_to_config
+    def __init__(
+        self,
+        patch_size: int = 1,
+        in_channels: int = 64,
+        out_channels: Optional[int] = None,
+        num_layers: int = 19,
+        num_single_layers: int = 38,
+        attention_head_dim: int = 128,
+        num_attention_heads: int = 24,
+        joint_attention_dim: int = 4096,
+        pooled_projection_dim: int = 768,
+        guidance_embeds: bool = False,
+        axes_dims_rope: Tuple[int] = (16, 56, 56),
+    ):
+        super().__init__(patch_size,
+                         in_channels,
+                         out_channels,
+                         num_layers,
+                         num_single_layers,
+                         attention_head_dim,
+                         num_attention_heads,
+                         joint_attention_dim,
+                         pooled_projection_dim,
+                         guidance_embeds,
+                         axes_dims_rope)
+
+    def forward(self,
+                hidden_states: torch.Tensor,
+                condition_latents: List[torch.Tensor],
+                condition_ids: List[torch.Tensor],
+                condition_type_ids: List[torch.Tensor],
+                condition_types: List[str],
+                model_config: Optional[Dict[str, Any]] = {},
+                return_condition_latents: bool = False,
+                c_t=0,
+                encoder_hidden_states: torch.Tensor = None,
+                pooled_projections: torch.Tensor = None,
+                timestep: torch.LongTensor = None,
+                img_ids: torch.Tensor = None,
+                txt_ids: torch.Tensor = None,
+                guidance: torch.Tensor = None,
+                joint_attention_kwargs: Optional[Dict[str, Any]] = None,
+                controlnet_block_samples=None,
+                controlnet_single_block_samples=None,
+                return_dict: bool = True,
+                controlnet_blocks_repeat: bool = False,
+            ) -> tuple[Any, None] | tuple[Any, Any | None] | Transformer2DModelOutput:
+        use_condition = condition_latents is not None
+
+        # lora scale
+        if joint_attention_kwargs is not None:
+            joint_attention_kwargs = joint_attention_kwargs.copy()
+            lora_scale = joint_attention_kwargs.pop("scale", 1.0)
+        else:
+            lora_scale = 1.0
+
+        if USE_PEFT_BACKEND:
+            # MAYBE a conflict when loading multi-loras, seems to weight them together. Weight the lora layers by setting `lora_scale` for each PEFT layer
+            scale_lora_layers(self, lora_scale)
+        else:
+            if joint_attention_kwargs is not None and joint_attention_kwargs.get("scale", None) is not None:
+                logger.warning(
+                    "Passing `scale` via `joint_attention_kwargs` when not using the PEFT backend is ineffective."
+                )
+        # hidden_state proj
+        with enable_lora([self.x_embedder],[item for item in module_active_adapters(self.x_embedder) if item not in condition_types]):
+            hidden_states = self.x_embedder(hidden_states)
+        # condition proj
+        if use_condition:
+            condition_latents = copy.deepcopy(condition_latents)
+            for i, cond_type in enumerate(condition_types):
+                with enable_lora([self.x_embedder],[cond_type]):
+                    condition_latents[i] = self.x_embedder(condition_latents[i])
+
+        # text_embedding proj
+        encoder_hidden_states = self.context_embedder(encoder_hidden_states)
+
+        # prepare for timestep and guidance value
+        timestep = timestep.to(hidden_states.dtype) * 1000
+        if guidance is not None:
+            guidance = guidance.to(hidden_states.dtype) * 1000
+        else:
+            guidance = None
+
+        # computing the time_poolingtext_guidance embedding for the text branch and the denoising branch
+        temb = (
+            self.time_text_embed(timestep, pooled_projections)
+            if guidance is None
+            else self.time_text_embed(timestep, guidance, pooled_projections)
+        )
+        # computing the time_poolingtext_guidance embedding for the conditional branches
+        cond_temb = (
+            self.time_text_embed(torch.ones_like(timestep) * c_t * 1000, pooled_projections)
+            if guidance is None
+            else self.time_text_embed(torch.ones_like(timestep) * c_t * 1000, guidance, pooled_projections)
+        )
+
+        # not use in this version
+        if hasattr(self, "cond_type_embed") and condition_type_ids is not None:
+            cond_type_proj = self.time_text_embed.time_proj(condition_type_ids[0])
+            cond_type_emb = self.cond_type_embed(cond_type_proj.to(dtype=cond_temb.dtype))
+            cond_temb = cond_temb + cond_type_emb
+
+        # Rotary Positional Embedding
+        if txt_ids.ndim == 3:
+            logger.warning(
+                "Passing `txt_ids` 3d torch.Tensor is deprecated."
+                "Please remove the batch dimension and pass it as a 2d torch Tensor"
+            )
+            txt_ids = txt_ids[0]
+        if img_ids.ndim == 3:
+            logger.warning(
+                "Passing `img_ids` 3d torch.Tensor is deprecated."
+                "Please remove the batch dimension and pass it as a 2d torch Tensor"
+            )
+            img_ids = img_ids[0]
+
+        ids = torch.cat((txt_ids, img_ids), dim=0)
+        image_rotary_emb = tuple(i.to(self.dtype) for i in self.pos_embed(ids))
+        cond_rotary_embs = []
+        if use_condition:
+            for cond_id in condition_ids:
+                cond_rotary_embs.append(tuple(i.to(self.dtype) for i in self.pos_embed(cond_id)))
+
+        # process in mm-DiT_block
+        for index_block, block in enumerate(self.transformer_blocks):
+            encoder_hidden_states, hidden_states, condition_latents = block_forward(
+                block,
+                model_config=model_config,
+                hidden_states=hidden_states,
+                encoder_hidden_states=encoder_hidden_states,
+                condition_latents= condition_latents if use_condition else None,
+                condition_types = condition_types if use_condition else None,
+                temb=temb,
+                cond_temb=cond_temb if use_condition else None,
+                image_rotary_emb=image_rotary_emb,
+                cond_rotary_embs=cond_rotary_embs if use_condition else None,
+            )
+            # controlnet residual
+            if controlnet_block_samples is not None:
+                interval_control = len(self.transformer_blocks) / len(controlnet_block_samples)
+                interval_control = int(np.ceil(interval_control))
+                hidden_states = (hidden_states + controlnet_block_samples[index_block // interval_control])
+
+        hidden_states = torch.cat([encoder_hidden_states, hidden_states], dim=1)
+
+        # process in single-DiT_block
+        for index_block, block in enumerate(self.single_transformer_blocks):
+            hidden_states, condition_latents = single_block_forward(
+                block,
+                model_config=model_config,
+                hidden_states=hidden_states,
+                condition_latents= condition_latents if use_condition else None,
+                condition_types=condition_types if use_condition else None,
+                temb=temb,
+                cond_temb= cond_temb if use_condition else None,
+                image_rotary_emb=image_rotary_emb,
+                cond_rotary_embs= cond_rotary_embs if use_condition else None,
+            )
+            # controlnet residual
+            if controlnet_single_block_samples is not None:
+                interval_control = len(self.single_transformer_blocks) / len(controlnet_single_block_samples)
+                interval_control = int(np.ceil(interval_control))
+                hidden_states[:, encoder_hidden_states.shape[1]:, ...] = (
+                        hidden_states[:, encoder_hidden_states.shape[1]:, ...]+ controlnet_single_block_samples[index_block // interval_control]
+                )
+
+        hidden_states = hidden_states[:, encoder_hidden_states.shape[1]:, ...]
+
+        hidden_states = self.norm_out(hidden_states, temb).to(self.dtype)
+        output = self.proj_out(hidden_states)
+        if return_condition_latents:
+            condition_latents = [ self.proj_out(self.norm_out(i, cond_temb)) if use_condition else None for i in condition_latents]
+
+        if USE_PEFT_BACKEND:
+            unscale_lora_layers(self, lora_scale)
+        if not return_dict:
+            return (output,None) if not return_condition_latents else (output, condition_latents)
+
+        return Transformer2DModelOutput(sample=output)