SPF / newSPF /models /attn_processor.py

Upload 157 files

b1541cc verified about 1 year ago

12.4 kB

import os
import random
import argparse
from pathlib import Path
import json
import itertools
import time
import sys
from typing import Any, Optional, Tuple, Union
sys.path.append( os.path.dirname(os.path.abspath(__file__) ) )
import cv2
import numpy as np
import torch
import torch.nn.functional as F
import torch.nn as nn
import matplotlib.cm as cm

from torchvision import transforms
from PIL import Image
from transformers import CLIPImageProcessor
from accelerate import Accelerator
from accelerate.logging import get_logger
from accelerate.utils import ProjectConfiguration
from diffusers import AutoencoderKL, DDPMScheduler
from diffusers.models.lora import LoRALinearLayer
from transformers import CLIPTextModel, CLIPTokenizer, CLIPVisionModelWithProjection, Blip2QFormerModel

from diffusers.models.attention import Attention

def visual_map(query, encoder_hidden_states_key_proj, token_index):
    attn_map = (query @ encoder_hidden_states_key_proj.transpose(-2, -1)).softmax(-1)

    vis = attn_map.mean(dim = 1)[1].transpose(-2, -1).view(-1, 64, 64).float().detach().cpu().numpy()[token_index]
    vis = ((vis-vis.min())/(vis.max() - vis.min()) *255).astype(np.uint8)
    colormap = cm.get_cmap('rainbow')
    rainbow_img_array = colormap(vis / 255.0)
    rainbow_img_array = (rainbow_img_array[:, :, :3] * 255).astype(np.uint8)
    return Image.fromarray(rainbow_img_array).resize((512,512)).convert("RGB")

class SD3IPAdapterJointAttnProcessor2_0(nn.Module):
    """
    Attention processor for IP-Adapter used typically in processing the SD3-like self-attention projections, with
    additional image-based information and timestep embeddings.
    Args:
        hidden_size (`int`):
            The number of hidden channels.
        ip_hidden_states_dim (`int`):
            The image feature dimension.
        head_dim (`int`):
            The number of head channels.
        timesteps_emb_dim (`int`, defaults to 1280):
            The number of input channels for timestep embedding.
        scale (`float`, defaults to 0.5):
            IP-Adapter scale.
        context_norm_type ('str', defaults to 'ada_norm_continous'):
            IP-Adapter text input norm layer
    """

    def __init__(
        self,
        hidden_size: int,
        ip_hidden_states_dim: int,
        head_dim: int,
        timesteps_emb_dim: int = 1280,
        scale: float = 0.5,
        context_norm_type: str = "ada_norm_continous", 
    ):
        super().__init__()

        # To prevent circular import
        from .normalization import AdaLayerNorm, RMSNorm

        self.norm_ip = AdaLayerNorm(timesteps_emb_dim, output_dim=ip_hidden_states_dim * 2, norm_eps=1e-6, chunk_dim=1)

        self.to_k_ip = nn.Linear(ip_hidden_states_dim, hidden_size, bias=False)
        self.to_v_ip = nn.Linear(ip_hidden_states_dim, hidden_size, bias=False)
        self.norm_q = RMSNorm(head_dim, 1e-6)
        self.norm_k = RMSNorm(head_dim, 1e-6)
        self.norm_ip_k = RMSNorm(head_dim, 1e-6)
        self.scale = scale

    def __call__(
        self,
        attn: Attention,
        hidden_states: torch.FloatTensor,
        encoder_hidden_states: torch.FloatTensor = None,
        attention_mask: Optional[torch.FloatTensor] = None,
        ip_hidden_states: torch.FloatTensor = None,
        temb: torch.FloatTensor = None,
    ) -> torch.FloatTensor:
        """
        Perform the attention computation, integrating image features (if provided) and timestep embeddings.
        If `ip_hidden_states` is `None`, this is equivalent to using JointAttnProcessor2_0.
        Args:
            attn (`Attention`):
                Attention instance.
            hidden_states (`torch.FloatTensor`):
                Input `hidden_states`.
            encoder_hidden_states (`torch.FloatTensor`, *optional*):
                The encoder hidden states.
            attention_mask (`torch.FloatTensor`, *optional*):
                Attention mask.
            ip_hidden_states (`torch.FloatTensor`, *optional*):
                Image embeddings.
            temb (`torch.FloatTensor`, *optional*):
                Timestep embeddings.
        Returns:
            `torch.FloatTensor`: Output hidden states.
        """
        residual = hidden_states

        batch_size = hidden_states.shape[0]

        # `sample` projections.
        query = attn.to_q(hidden_states)
        key = attn.to_k(hidden_states)
        value = attn.to_v(hidden_states)

        inner_dim = key.shape[-1]
        head_dim = inner_dim // attn.heads

        query = query.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
        key = key.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
        value = value.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
        img_query = query
        img_key = key
        img_value = value

        if attn.norm_q is not None:
            query = attn.norm_q(query)
        if attn.norm_k is not None:
            key = attn.norm_k(key)

        # `context` projections.
        if encoder_hidden_states is not None:
            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)

            query = torch.cat([query, encoder_hidden_states_query_proj], dim=2)
            key = torch.cat([key, encoder_hidden_states_key_proj], dim=2)
            value = torch.cat([value, encoder_hidden_states_value_proj], dim=2)

        hidden_states = F.scaled_dot_product_attention(query, key, value, dropout_p=0.0, is_causal=False)
        hidden_states = hidden_states.transpose(1, 2).reshape(batch_size, -1, attn.heads * head_dim)
        hidden_states = hidden_states.to(query.dtype)

        

        if encoder_hidden_states is not None:
            # Split the attention outputs.
            hidden_states, encoder_hidden_states = (
                hidden_states[:, : residual.shape[1]],
                hidden_states[:, residual.shape[1] :],
            )
            if not attn.context_pre_only:
                encoder_hidden_states = attn.to_add_out(encoder_hidden_states)

        # IP Adapter
        if self.scale != 0 and ip_hidden_states is not None:
            # Norm image features
            norm_ip_hidden_states = self.norm_ip(ip_hidden_states, temb=temb)

            # To k and v
            ip_key = self.to_k_ip(norm_ip_hidden_states)
            ip_value = self.to_v_ip(norm_ip_hidden_states)

            # Reshape
            ip_key = ip_key.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
            ip_value = ip_value.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)

            # Norm
            query = self.norm_q(img_query)
            img_key = self.norm_k(img_key)
            ip_key = self.norm_ip_k(ip_key)

            # cat img
            key = torch.cat([img_key, ip_key], dim=2)
            value = torch.cat([img_value, ip_value], dim=2)

            ip_hidden_states = F.scaled_dot_product_attention(query, key, value, dropout_p=0.0, is_causal=False)
            ip_hidden_states = ip_hidden_states.transpose(1, 2).view(batch_size, -1, attn.heads * head_dim)
            ip_hidden_states = ip_hidden_states.to(query.dtype)

            hidden_states = hidden_states + ip_hidden_states * self.scale

        # linear proj
        hidden_states = attn.to_out[0](hidden_states)
        # dropout
        hidden_states = attn.to_out[1](hidden_states)

        if encoder_hidden_states is not None:
            return hidden_states, encoder_hidden_states
        else:
            return hidden_states

class NormalJointAttnProcessor2_0():
    """Attention processor used typically in processing the SD3-like self-attention projections."""

    def __init__(self):
        if not hasattr(F, "scaled_dot_product_attention"):
            raise ImportError("JointAttnProcessor2_0 requires PyTorch 2.0, to use it, please upgrade PyTorch to 2.0.")

    def __call__(
        self,
        attn: Attention,
        hidden_states: torch.FloatTensor,
        encoder_hidden_states: torch.FloatTensor = None,
        attention_mask: Optional[torch.FloatTensor] = None,
        *args,
        **kwargs,
    ) -> torch.FloatTensor:
        residual = hidden_states

        batch_size = hidden_states.shape[0]

        # `sample` projections.
        query = attn.to_q(hidden_states)
        key = attn.to_k(hidden_states)
        value = attn.to_v(hidden_states)

        inner_dim = key.shape[-1]
        head_dim = inner_dim // attn.heads

        query = query.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
        key = key.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
        value = 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:
            key = attn.norm_k(key)

        self.query = query

        # `context` projections.
        if encoder_hidden_states is not None:
            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)

            self.QKQ_attn = F.scaled_dot_product_attention(
                encoder_hidden_states_query_proj, key, value , dropout_p=0.0, is_causal=False
            )

            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)

            query = torch.cat([query, encoder_hidden_states_query_proj], dim=2)
            key = torch.cat([key, encoder_hidden_states_key_proj], dim=2)
            value = torch.cat([value, encoder_hidden_states_value_proj], dim=2)
            
            
        hidden_states = F.scaled_dot_product_attention(query, key, value, dropout_p=0.0, is_causal=False)
        hidden_states = hidden_states.transpose(1, 2).reshape(batch_size, -1, attn.heads * head_dim)
        hidden_states = hidden_states.to(query.dtype)

        if encoder_hidden_states is not None:
            # Split the attention outputs.
            hidden_states, encoder_hidden_states = (
                hidden_states[:, : residual.shape[1]],
                hidden_states[:, residual.shape[1] :],
            )
            if not attn.context_pre_only:
                encoder_hidden_states = attn.to_add_out(encoder_hidden_states)

        # linear proj
        hidden_states = attn.to_out[0](hidden_states)
        # dropout
        hidden_states = attn.to_out[1](hidden_states)

        if encoder_hidden_states is not None:
            return hidden_states, encoder_hidden_states
        else:
            return hidden_states

	import os
	import random
	import argparse
	from pathlib import Path
	import json
	import itertools
	import time
	import sys
	from typing import Any, Optional, Tuple, Union
	sys.path.append( os.path.dirname(os.path.abspath(__file__) ) )
	import cv2
	import numpy as np
	import torch
	import torch.nn.functional as F
	import torch.nn as nn
	import matplotlib.cm as cm

	from torchvision import transforms
	from PIL import Image
	from transformers import CLIPImageProcessor
	from accelerate import Accelerator
	from accelerate.logging import get_logger
	from accelerate.utils import ProjectConfiguration
	from diffusers import AutoencoderKL, DDPMScheduler
	from diffusers.models.lora import LoRALinearLayer
	from transformers import CLIPTextModel, CLIPTokenizer, CLIPVisionModelWithProjection, Blip2QFormerModel

	from diffusers.models.attention import Attention

	def visual_map(query, encoder_hidden_states_key_proj, token_index):
	attn_map = (query @ encoder_hidden_states_key_proj.transpose(-2, -1)).softmax(-1)

	vis = attn_map.mean(dim = 1)[1].transpose(-2, -1).view(-1, 64, 64).float().detach().cpu().numpy()[token_index]
	vis = ((vis-vis.min())/(vis.max() - vis.min()) *255).astype(np.uint8)
	colormap = cm.get_cmap('rainbow')
	rainbow_img_array = colormap(vis / 255.0)
	rainbow_img_array = (rainbow_img_array[:, :, :3] * 255).astype(np.uint8)
	return Image.fromarray(rainbow_img_array).resize((512,512)).convert("RGB")

	class SD3IPAdapterJointAttnProcessor2_0(nn.Module):
	"""
	Attention processor for IP-Adapter used typically in processing the SD3-like self-attention projections, with
	additional image-based information and timestep embeddings.

	Args:
	hidden_size (`int`):
	The number of hidden channels.
	ip_hidden_states_dim (`int`):
	The image feature dimension.
	head_dim (`int`):
	The number of head channels.
	timesteps_emb_dim (`int`, defaults to 1280):
	The number of input channels for timestep embedding.
	scale (`float`, defaults to 0.5):
	IP-Adapter scale.
	context_norm_type ('str', defaults to 'ada_norm_continous'):
	IP-Adapter text input norm layer
	"""

	def __init__(
	self,
	hidden_size: int,
	ip_hidden_states_dim: int,
	head_dim: int,
	timesteps_emb_dim: int = 1280,
	scale: float = 0.5,
	context_norm_type: str = "ada_norm_continous",
	):
	super().__init__()

	# To prevent circular import
	from .normalization import AdaLayerNorm, RMSNorm

	self.norm_ip = AdaLayerNorm(timesteps_emb_dim, output_dim=ip_hidden_states_dim * 2, norm_eps=1e-6, chunk_dim=1)

	self.to_k_ip = nn.Linear(ip_hidden_states_dim, hidden_size, bias=False)
	self.to_v_ip = nn.Linear(ip_hidden_states_dim, hidden_size, bias=False)
	self.norm_q = RMSNorm(head_dim, 1e-6)
	self.norm_k = RMSNorm(head_dim, 1e-6)
	self.norm_ip_k = RMSNorm(head_dim, 1e-6)
	self.scale = scale

	def __call__(
	self,
	attn: Attention,
	hidden_states: torch.FloatTensor,
	encoder_hidden_states: torch.FloatTensor = None,
	attention_mask: Optional[torch.FloatTensor] = None,
	ip_hidden_states: torch.FloatTensor = None,
	temb: torch.FloatTensor = None,
	) -> torch.FloatTensor:
	"""
	Perform the attention computation, integrating image features (if provided) and timestep embeddings.

	If `ip_hidden_states` is `None`, this is equivalent to using JointAttnProcessor2_0.

	Args:
	attn (`Attention`):
	Attention instance.
	hidden_states (`torch.FloatTensor`):
	Input `hidden_states`.
	encoder_hidden_states (`torch.FloatTensor`, optional):
	The encoder hidden states.
	attention_mask (`torch.FloatTensor`, optional):
	Attention mask.
	ip_hidden_states (`torch.FloatTensor`, optional):
	Image embeddings.
	temb (`torch.FloatTensor`, optional):
	Timestep embeddings.

	Returns:
	`torch.FloatTensor`: Output hidden states.
	"""
	residual = hidden_states

	batch_size = hidden_states.shape[0]

	# `sample` projections.
	query = attn.to_q(hidden_states)
	key = attn.to_k(hidden_states)
	value = attn.to_v(hidden_states)

	inner_dim = key.shape[-1]
	head_dim = inner_dim // attn.heads

	query = query.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
	key = key.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
	value = value.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
	img_query = query
	img_key = key
	img_value = value

	if attn.norm_q is not None:
	query = attn.norm_q(query)
	if attn.norm_k is not None:
	key = attn.norm_k(key)

	# `context` projections.
	if encoder_hidden_states is not None:
	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)

	query = torch.cat([query, encoder_hidden_states_query_proj], dim=2)
	key = torch.cat([key, encoder_hidden_states_key_proj], dim=2)
	value = torch.cat([value, encoder_hidden_states_value_proj], dim=2)

	hidden_states = F.scaled_dot_product_attention(query, key, value, dropout_p=0.0, is_causal=False)
	hidden_states = hidden_states.transpose(1, 2).reshape(batch_size, -1, attn.heads * head_dim)
	hidden_states = hidden_states.to(query.dtype)



	if encoder_hidden_states is not None:
	# Split the attention outputs.
	hidden_states, encoder_hidden_states = (
	hidden_states[:, : residual.shape[1]],
	hidden_states[:, residual.shape[1] :],
	)
	if not attn.context_pre_only:
	encoder_hidden_states = attn.to_add_out(encoder_hidden_states)

	# IP Adapter
	if self.scale != 0 and ip_hidden_states is not None:
	# Norm image features
	norm_ip_hidden_states = self.norm_ip(ip_hidden_states, temb=temb)

	# To k and v
	ip_key = self.to_k_ip(norm_ip_hidden_states)
	ip_value = self.to_v_ip(norm_ip_hidden_states)

	# Reshape
	ip_key = ip_key.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
	ip_value = ip_value.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)

	# Norm
	query = self.norm_q(img_query)
	img_key = self.norm_k(img_key)
	ip_key = self.norm_ip_k(ip_key)

	# cat img
	key = torch.cat([img_key, ip_key], dim=2)
	value = torch.cat([img_value, ip_value], dim=2)

	ip_hidden_states = F.scaled_dot_product_attention(query, key, value, dropout_p=0.0, is_causal=False)
	ip_hidden_states = ip_hidden_states.transpose(1, 2).view(batch_size, -1, attn.heads * head_dim)
	ip_hidden_states = ip_hidden_states.to(query.dtype)

	hidden_states = hidden_states + ip_hidden_states * self.scale

	# linear proj
	hidden_states = attn.to_out[0](hidden_states)
	# dropout
	hidden_states = attn.to_out[1](hidden_states)

	if encoder_hidden_states is not None:
	return hidden_states, encoder_hidden_states
	else:
	return hidden_states

	class NormalJointAttnProcessor2_0():
	"""Attention processor used typically in processing the SD3-like self-attention projections."""

	def __init__(self):
	if not hasattr(F, "scaled_dot_product_attention"):
	raise ImportError("JointAttnProcessor2_0 requires PyTorch 2.0, to use it, please upgrade PyTorch to 2.0.")

	def __call__(
	self,
	attn: Attention,
	hidden_states: torch.FloatTensor,
	encoder_hidden_states: torch.FloatTensor = None,
	attention_mask: Optional[torch.FloatTensor] = None,
	*args,
	**kwargs,
	) -> torch.FloatTensor:
	residual = hidden_states

	batch_size = hidden_states.shape[0]

	# `sample` projections.
	query = attn.to_q(hidden_states)
	key = attn.to_k(hidden_states)
	value = attn.to_v(hidden_states)

	inner_dim = key.shape[-1]
	head_dim = inner_dim // attn.heads

	query = query.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
	key = key.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
	value = 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:
	key = attn.norm_k(key)

	self.query = query

	# `context` projections.
	if encoder_hidden_states is not None:
	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)

	self.QKQ_attn = F.scaled_dot_product_attention(
	encoder_hidden_states_query_proj, key, value , dropout_p=0.0, is_causal=False
	)

	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)

	query = torch.cat([query, encoder_hidden_states_query_proj], dim=2)
	key = torch.cat([key, encoder_hidden_states_key_proj], dim=2)
	value = torch.cat([value, encoder_hidden_states_value_proj], dim=2)


	hidden_states = F.scaled_dot_product_attention(query, key, value, dropout_p=0.0, is_causal=False)
	hidden_states = hidden_states.transpose(1, 2).reshape(batch_size, -1, attn.heads * head_dim)
	hidden_states = hidden_states.to(query.dtype)

	if encoder_hidden_states is not None:
	# Split the attention outputs.
	hidden_states, encoder_hidden_states = (
	hidden_states[:, : residual.shape[1]],
	hidden_states[:, residual.shape[1] :],
	)
	if not attn.context_pre_only:
	encoder_hidden_states = attn.to_add_out(encoder_hidden_states)

	# linear proj
	hidden_states = attn.to_out[0](hidden_states)
	# dropout
	hidden_states = attn.to_out[1](hidden_states)

	if encoder_hidden_states is not None:
	return hidden_states, encoder_hidden_states
	else:
	return hidden_states