src/SubjectGeniusTransformer2DModel.py

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)