import ipdb import torch from typing import List, Optional, Dict, Any from torch import FloatTensor, Tensor from diffusers.models.attention_processor import Attention, F from .lora_switching_module import enable_lora,module_active_adapters from diffusers.models.embeddings import apply_rotary_emb def attn_forward( attn: Attention, hidden_states: torch.FloatTensor, condition_types: List[str], encoder_hidden_states: torch.FloatTensor = None, condition_latents: torch.FloatTensor = None, attention_mask: Optional[torch.FloatTensor] = None, image_rotary_emb: Optional[torch.Tensor] = None, cond_rotary_embs: Optional[List[torch.Tensor]] = None, model_config: Optional[Dict[str, Any]] = {}, ) -> tuple[Any, Any, list[FloatTensor] | None] | tuple[Any, Any] | tuple[Tensor, Tensor] | Tensor: batch_size, seq_len, _ = hidden_states.shape # base_key / base_value: [text,noise] if encoder_hidden_states is not None else [noise] with enable_lora([attn.to_q, attn.to_k, attn.to_v], [item for item in module_active_adapters(attn.to_q) if item not in condition_types]): base_key = attn.to_k(hidden_states) base_value = attn.to_v(hidden_states) query = attn.to_q(hidden_states) inner_dim = query.shape[-1] head_dim = inner_dim // attn.heads query = query.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2) base_key = base_key.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2) base_value = base_value.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2) if attn.norm_q is not None: query = attn.norm_q(query) if attn.norm_k is not None: base_key = attn.norm_k(base_key) # the attention in FluxSingleTransformerBlock does not use `encoder_hidden_states` if encoder_hidden_states is not None: # `context` projections. seq_len = seq_len + encoder_hidden_states.shape[1] encoder_hidden_states_query_proj = attn.add_q_proj(encoder_hidden_states) encoder_hidden_states_key_proj = attn.add_k_proj(encoder_hidden_states) encoder_hidden_states_value_proj = attn.add_v_proj(encoder_hidden_states) encoder_hidden_states_query_proj = encoder_hidden_states_query_proj.view( batch_size, -1, attn.heads, head_dim ).transpose(1, 2) encoder_hidden_states_key_proj = encoder_hidden_states_key_proj.view( batch_size, -1, attn.heads, head_dim ).transpose(1, 2) encoder_hidden_states_value_proj = encoder_hidden_states_value_proj.view( batch_size, -1, attn.heads, head_dim ).transpose(1, 2) if attn.norm_added_q is not None: encoder_hidden_states_query_proj = attn.norm_added_q( encoder_hidden_states_query_proj ) if attn.norm_added_k is not None: encoder_hidden_states_key_proj = attn.norm_added_k( encoder_hidden_states_key_proj ) # concat the text embedding and noise embedding query = torch.cat([encoder_hidden_states_query_proj, query], dim=2) base_key = torch.cat([encoder_hidden_states_key_proj, base_key], dim=2) base_value = torch.cat([encoder_hidden_states_value_proj, base_value], dim=2) if image_rotary_emb is not None: query = apply_rotary_emb(query, image_rotary_emb) base_key = apply_rotary_emb(base_key, image_rotary_emb) condition_latents_output_list = [] key = base_key value = base_value if condition_latents is not None and len(condition_latents) > 0: for i, cond_type in enumerate(condition_types): with enable_lora([attn.to_q,attn.to_k, attn.to_v], [cond_type]): cond_query = attn.to_q(condition_latents[i]) cond_key = attn.to_k(condition_latents[i]) cond_value = attn.to_v(condition_latents[i]) cond_query = cond_query.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2) cond_key = cond_key.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2) cond_value = cond_value.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2) if attn.norm_q is not None: cond_query = attn.norm_q(cond_query) if attn.norm_k is not None: cond_key = attn.norm_k(cond_key) if cond_rotary_embs is not None: cond_query = apply_rotary_emb(cond_query, cond_rotary_embs[i]) cond_key = apply_rotary_emb(cond_key, cond_rotary_embs[i]) key = torch.cat([key, cond_key], dim=2) value = torch.cat([value, cond_value], dim=2) mix_cond_key = torch.cat([base_key, cond_key], dim=2) mix_cond_value = torch.cat([base_value, cond_value], dim=2) condition_latents_output = F.scaled_dot_product_attention( cond_query, mix_cond_key, mix_cond_value, dropout_p=0.0, is_causal=False, attn_mask=attention_mask ) condition_latents_output = condition_latents_output.transpose(1, 2).reshape(batch_size, -1, attn.heads * head_dim) condition_latents_output_list.append(condition_latents_output) hidden_states = F.scaled_dot_product_attention( query, key, value, dropout_p=0.0, is_causal=False, attn_mask=attention_mask ) hidden_states = hidden_states.transpose(1, 2).reshape( batch_size, -1, attn.heads * head_dim ) if encoder_hidden_states is not None: encoder_hidden_states, hidden_states = ( hidden_states[:, : encoder_hidden_states.shape[1]], hidden_states[:, encoder_hidden_states.shape[1] :], ) with enable_lora([attn.to_out[0]], [item for item in module_active_adapters(attn.to_out[0]) if item not in condition_types]): # linear proj hidden_states = attn.to_out[0](hidden_states) # dropout hidden_states = attn.to_out[1](hidden_states) encoder_hidden_states = attn.to_add_out(encoder_hidden_states) if condition_latents is not None and len(condition_latents) > 0: for i, cond_type in enumerate(condition_types): with enable_lora([attn.to_out[0]], [cond_type]): condition_latents_output_list[i] = attn.to_out[0](condition_latents_output_list[i]) condition_latents_output_list[i] = attn.to_out[1](condition_latents_output_list[i]) return hidden_states, encoder_hidden_states, condition_latents_output_list else: return hidden_states, condition_latents_output_list def block_forward( self, hidden_states: torch.Tensor, encoder_hidden_states: torch.Tensor, condition_latents: List[torch.Tensor] = None, temb: torch.Tensor = None, cond_temb: List[torch.Tensor] = None, cond_rotary_embs=None, image_rotary_emb=None, condition_types: List[str]=None, model_config: Optional[Dict[str, Any]] = {}, ): use_cond = condition_latents is not None and len(condition_latents) > 0 # norm : hidden_states->norm_hidden_states, encoder_hidden_states->norm_encoder_hidden_states, condition_latents->norm_condition_latent_list with enable_lora([self.norm1.linear], [item for item in module_active_adapters(self.norm1.linear) if item not in condition_types]): norm_hidden_states, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.norm1( hidden_states, emb=temb ) norm_encoder_hidden_states, c_gate_msa, c_shift_mlp, c_scale_mlp, c_gate_mlp = ( self.norm1_context(encoder_hidden_states, emb=temb) ) norm_condition_latent_list = [] cond_gate_msa_list = [] cond_shift_mlp_list = [] cond_scale_mlp_list = [] cond_gate_mlp_list = [] if use_cond: for i, cond_type in enumerate(condition_types): with enable_lora([self.norm1.linear],[cond_type]): norm_condition_latent,cond_gate_msa,cond_shift_mlp,cond_scale_mlp,cond_gate_mlp,= self.norm1( condition_latents[i], emb=cond_temb ) norm_condition_latent_list.append(norm_condition_latent) cond_gate_msa_list.append(cond_gate_msa) cond_shift_mlp_list.append(cond_shift_mlp) cond_scale_mlp_list.append(cond_scale_mlp) cond_gate_mlp_list.append(cond_gate_mlp) # Attention. attn_output, context_attn_output, cond_attn_output_list attn_output, context_attn_output,cond_attn_output_list = attn_forward( self.attn, model_config=model_config, hidden_states=norm_hidden_states, condition_types=condition_types, encoder_hidden_states=norm_encoder_hidden_states, condition_latents=norm_condition_latent_list if use_cond else None, image_rotary_emb=image_rotary_emb, cond_rotary_embs=cond_rotary_embs if use_cond else None, ) # Process attention outputs. Gate + Resnet. hidden_states, encoder_hidden_states, condition_latents # 1. hidden_states attn_output = gate_msa.unsqueeze(1) * attn_output hidden_states = hidden_states + attn_output # 2. encoder_hidden_states context_attn_output = c_gate_msa.unsqueeze(1) * context_attn_output encoder_hidden_states = encoder_hidden_states + context_attn_output # 3. condition_latents if use_cond: for i, cond_type in enumerate(condition_types): cond_attn_output_list[i] = cond_gate_msa_list[i].unsqueeze(1) * cond_attn_output_list[i] condition_latents[i] = condition_latents[i] + cond_attn_output_list[i] if model_config.get("add_cond_attn", False): hidden_states += cond_attn_output_list[i] # LayerNorm + Scaling + Shift. # hidden_states->norm_hidden_states, encoder_hidden_states->norm_encoder_hidden_states, condition_latents->norm_condition_latent_list # 1. hidden_states norm_hidden_states = self.norm2(hidden_states) norm_hidden_states = norm_hidden_states * (1 + scale_mlp[:, None]) + shift_mlp[:, None] # 2. encoder_hidden_states norm_encoder_hidden_states = self.norm2_context(encoder_hidden_states) norm_encoder_hidden_states = norm_encoder_hidden_states * (1 + c_scale_mlp[:, None]) + c_shift_mlp[:, None] # 3. condition_latents if use_cond: for i, cond_type in enumerate(condition_types): norm_condition_latent_list[i] = self.norm2(condition_latents[i]) norm_condition_latent_list[i] = norm_condition_latent_list[i] * (1 + cond_scale_mlp_list[i][:, None]) + cond_shift_mlp_list[i][:, None] # MLP Feed-forward + Gate # 1. hidden_states with enable_lora([self.ff.net[2]], [item for item in module_active_adapters(self.ff.net[2]) if item not in condition_types]): hidden_states = hidden_states + gate_mlp.unsqueeze(1) * self.ff(norm_hidden_states) # 2. encoder_hidden_states encoder_hidden_states = encoder_hidden_states + c_gate_mlp.unsqueeze(1) * self.ff_context(norm_encoder_hidden_states) # 3. condition_latents if use_cond: for i, cond_type in enumerate(condition_types): with enable_lora([self.ff.net[2]], [cond_type]): condition_latents[i] = condition_latents[i] + cond_gate_mlp_list[i].unsqueeze(1) * self.ff(norm_condition_latent_list[i]) # Clip to avoid overflow. if encoder_hidden_states.dtype == torch.float16: encoder_hidden_states = encoder_hidden_states.clip(-65504, 65504) return encoder_hidden_states, hidden_states, condition_latents if use_cond else None def single_block_forward( self, hidden_states: torch.Tensor, condition_latents: List[torch.Tensor] = None, temb: torch.Tensor = None, cond_temb: List[torch.Tensor] = None, image_rotary_emb=None, cond_rotary_embs=None, condition_types: List[str] = None, model_config: Optional[Dict[str, Any]] = {}, ): using_cond = condition_latents is not None and len(condition_latents) > 0 with enable_lora([self.norm.linear,self.proj_mlp],[item for item in module_active_adapters(self.norm.linear) if item not in condition_types]): norm_hidden_states, gate = self.norm(hidden_states, emb=temb) mlp_hidden_states = self.act_mlp(self.proj_mlp(norm_hidden_states)) norm_condition_latent_list = [] mlp_condition_latent_list = [] cond_gate_list = [] if using_cond: for i, cond_type in enumerate(condition_types): with enable_lora([self.norm.linear, self.proj_mlp],[cond_type]): norm_condition_latents, cond_gate = self.norm(condition_latents[i], emb=cond_temb) mlp_condition_latents = self.act_mlp(self.proj_mlp(norm_condition_latents)) norm_condition_latent_list.append(norm_condition_latents) mlp_condition_latent_list.append(mlp_condition_latents) cond_gate_list.append(cond_gate) attn_output, cond_attn_output = attn_forward( self.attn, model_config=model_config, hidden_states=norm_hidden_states, condition_types= condition_types, image_rotary_emb=image_rotary_emb, **( { "condition_latents": norm_condition_latent_list, "cond_rotary_embs": cond_rotary_embs if using_cond else None, } if using_cond else {} ), ) with enable_lora([self.proj_out], [item for item in module_active_adapters(self.proj_out) if item not in condition_types]): hidden_states = hidden_states + gate.unsqueeze(1) * self.proj_out(torch.cat([attn_output, mlp_hidden_states], dim=2)) if using_cond: for i, cond_type in enumerate(condition_types): with enable_lora([self.proj_out],[cond_type]): attn_mlp_condition_latents = torch.cat([cond_attn_output[i], mlp_condition_latent_list[i]], dim=2) attn_mlp_condition_latents = cond_gate_list[i].unsqueeze(1) * self.proj_out(attn_mlp_condition_latents) condition_latents[i] = condition_latents[i] + attn_mlp_condition_latents if hidden_states.dtype == torch.float16: hidden_states = hidden_states.clip(-65504, 65504) return (hidden_states,None) if not using_cond else (hidden_states, condition_latents)