

import math
from typing import Optional

import numpy as np
import torch
from torch import nn

from .activations import get_activation



def 			snake_case__    (					SCREAMING_SNAKE_CASE_	:					torch.Tensor			,  SCREAMING_SNAKE_CASE_	:					int			,  SCREAMING_SNAKE_CASE_	:					bool = False			,  SCREAMING_SNAKE_CASE_	:					float = 1			,  SCREAMING_SNAKE_CASE_	:					float = 1			,  SCREAMING_SNAKE_CASE_	:					int = 10_000			,  ):



     '''simple docstring'''





     assert len(timesteps.shape    ) == 1, "Timesteps should be a 1d-array"

     lowercase__					:     int   = embedding_dim // 2
     lowercase__					:     str   = -math.log(SCREAMING_SNAKE_CASE_    ) * torch.arange(
         start=0			,  end=SCREAMING_SNAKE_CASE_			,  dtype=torch.floataa			,  device=timesteps.device    )
     lowercase__					:     Optional[Any]   = exponent / (half_dim - downscale_freq_shift)

     lowercase__					:     Optional[int]   = torch.exp(SCREAMING_SNAKE_CASE_    )
     lowercase__					:     Optional[int]   = timesteps[:, None].float() * emb[None, :]

     # scale embeddings
     lowercase__					:     Dict   = scale * emb

     # concat sine and cosine embeddings
     lowercase__					:     List[Any]   = torch.cat([torch.sin(SCREAMING_SNAKE_CASE_    ), torch.cos(SCREAMING_SNAKE_CASE_    )]			,  dim=-1    )

     # flip sine and cosine embeddings
     if flip_sin_to_cos:
          lowercase__					:     Optional[int]   = torch.cat([emb[:, half_dim:], emb[:, :half_dim]]			,  dim=-1    )

     # zero pad
     if embedding_dim % 2 == 1:
          lowercase__					:     List[str]   = torch.nn.functional.pad(SCREAMING_SNAKE_CASE_			,  (0, 1, 0, 0)    )
     return emb



def 			snake_case__    (					SCREAMING_SNAKE_CASE_	:					List[str]			,  SCREAMING_SNAKE_CASE_	:					Dict			,  SCREAMING_SNAKE_CASE_	:					Any=False			,  SCREAMING_SNAKE_CASE_	:					Any=0    ):



     '''simple docstring'''





     lowercase__					:     Dict   = np.arange(SCREAMING_SNAKE_CASE_			,  dtype=np.floataa    )
     lowercase__					:     List[Any]   = np.arange(SCREAMING_SNAKE_CASE_			,  dtype=np.floataa    )
     lowercase__					:     Dict   = np.meshgrid(SCREAMING_SNAKE_CASE_			,  SCREAMING_SNAKE_CASE_    )  # here w goes first
     lowercase__					:     Optional[Any]   = np.stack(SCREAMING_SNAKE_CASE_			,  axis=0    )

     lowercase__					:     Tuple   = grid.reshape([2, 1, grid_size, grid_size]    )
     lowercase__					:     Tuple   = get_ad_sincos_pos_embed_from_grid(SCREAMING_SNAKE_CASE_			,  SCREAMING_SNAKE_CASE_    )
     if cls_token and extra_tokens > 0:
          lowercase__					:     Any   = np.concatenate([np.zeros([extra_tokens, embed_dim]    ), pos_embed]			,  axis=0    )
     return pos_embed



def 			snake_case__    (					SCREAMING_SNAKE_CASE_	:					Optional[Any]			,  SCREAMING_SNAKE_CASE_	:					str    ):



     '''simple docstring'''





     if embed_dim % 2 != 0:
          raise ValueError('embed_dim must be divisible by 2'    )

     # use half of dimensions to encode grid_h
     lowercase__					:     str   = get_ad_sincos_pos_embed_from_grid(embed_dim // 2			,  grid[0]    )  # (H*W, D/2)
     lowercase__					:     Optional[int]   = get_ad_sincos_pos_embed_from_grid(embed_dim // 2			,  grid[1]    )  # (H*W, D/2)

     lowercase__					:     List[str]   = np.concatenate([emb_h, emb_w]			,  axis=1    )  # (H*W, D)
     return emb



def 			snake_case__    (					SCREAMING_SNAKE_CASE_	:					str			,  SCREAMING_SNAKE_CASE_	:					str    ):



     '''simple docstring'''





     if embed_dim % 2 != 0:
          raise ValueError('embed_dim must be divisible by 2'    )

     lowercase__					:     List[Any]   = np.arange(embed_dim // 2			,  dtype=np.floataa    )
     omega /= embed_dim / 2.0
     lowercase__					:     int   = 1.0 / 10_000**omega  # (D/2,)

     lowercase__					:     str   = pos.reshape(-1    )  # (M,)
     lowercase__					:     str   = np.einsum('m,d->md'			,  SCREAMING_SNAKE_CASE_			,  SCREAMING_SNAKE_CASE_    )  # (M, D/2), outer product

     lowercase__					:     Dict   = np.sin(SCREAMING_SNAKE_CASE_    )  # (M, D/2)
     lowercase__					:     List[Any]   = np.cos(SCREAMING_SNAKE_CASE_    )  # (M, D/2)

     lowercase__					:     List[str]   = np.concatenate([emb_sin, emb_cos]			,  axis=1    )  # (M, D)
     return emb


class    SCREAMING_SNAKE_CASE__      (nn.Module  ):





    def __init__(   self		,     a=224		,     a=224		,     a=16		,     a=3		,     a=768		,     a=False		,     a=True		,     a=True		,     ):
         super().__init__()

         lowercase__					:     Dict   = (height // patch_size) * (width // patch_size)
         lowercase__					:     Any   = flatten
         lowercase__					:     str   = layer_norm

         lowercase__					:     Optional[Any]   = nn.Convad(
             a		,     a		,     kernel_size=(patch_size, patch_size)		,     stride=a		,     bias=a)
         if layer_norm:
              lowercase__					:     List[Any]   = nn.LayerNorm(a		,     elementwise_affine=a		,     eps=1e-6)
         else:
              lowercase__					:     List[Any]   = None

         lowercase__					:     List[str]   = get_ad_sincos_pos_embed(a		,     int(num_patches**0.5))
         self.register_buffer('pos_embed'		,     torch.from_numpy(a).float().unsqueeze(0)		,     persistent=a)





    def    snake_case_       (   self		,     a):
         lowercase__					:     str   = self.proj(a)
         if self.flatten:
              lowercase__					:     str   = latent.flatten(2).transpose(1		,     2)  # BCHW -> BNC
         if self.layer_norm:
              lowercase__					:     Tuple   = self.norm(a)
         return latent + self.pos_embed



class    SCREAMING_SNAKE_CASE__      (nn.Module  ):





    def __init__(   self		,     a		,     a		,     a = "silu"		,     a = None		,     a = None		,     a=None		,     ):
         super().__init__()

         lowercase__					:     Dict   = nn.Linear(a		,     a)

         if cond_proj_dim is not None:
              lowercase__					:     Union[str, Any]   = nn.Linear(a		,     a		,     bias=a)
         else:
              lowercase__					:     Optional[int]   = None

         lowercase__					:     Optional[Any]   = get_activation(a)

         if out_dim is not None:
              lowercase__					:     int   = out_dim
         else:
              lowercase__					:     Union[str, Any]   = time_embed_dim
         lowercase__					:     List[str]   = nn.Linear(a		,     a)

         if post_act_fn is None:
              lowercase__					:     int   = None
         else:
              lowercase__					:     List[Any]   = get_activation(a)





    def    snake_case_       (   self		,     a		,     a=None):
         if condition is not None:
              lowercase__					:     Dict   = sample + self.cond_proj(a)
         lowercase__					:     Any   = self.linear_a(a)

         if self.act is not None:
              lowercase__					:     str   = self.act(a)

         lowercase__					:     Union[str, Any]   = self.linear_a(a)

         if self.post_act is not None:
              lowercase__					:     Any   = self.post_act(a)
         return sample



class    SCREAMING_SNAKE_CASE__      (nn.Module  ):





    def __init__(   self		,     a		,     a		,     a):
         super().__init__()
         lowercase__					:     Tuple   = num_channels
         lowercase__					:     List[str]   = flip_sin_to_cos
         lowercase__					:     Union[str, Any]   = downscale_freq_shift





    def    snake_case_       (   self		,     a):
         lowercase__					:     int   = get_timestep_embedding(
             a		,     self.num_channels		,     flip_sin_to_cos=self.flip_sin_to_cos		,     downscale_freq_shift=self.downscale_freq_shift		,     )
         return t_emb



class    SCREAMING_SNAKE_CASE__      (nn.Module  ):





    def __init__(   self		,     a = 256		,     a = 1.0		,     a=True		,     a=True		,     a=False):
         super().__init__()
         lowercase__					:     Dict   = nn.Parameter(torch.randn(a) * scale		,     requires_grad=a)
         lowercase__					:     Any   = log
         lowercase__					:     Union[str, Any]   = flip_sin_to_cos

         if set_W_to_weight:
              # to delete later
              lowercase__					:     int   = nn.Parameter(torch.randn(a) * scale		,     requires_grad=a)

              lowercase__					:     Optional[Any]   = self.W





    def    snake_case_       (   self		,     a):
         if self.log:
              lowercase__					:     int   = torch.log(a)

         lowercase__					:     Optional[int]   = x[:, None] * self.weight[None, :] * 2 * np.pi

         if self.flip_sin_to_cos:
              lowercase__					:     Optional[int]   = torch.cat([torch.cos(a), torch.sin(a)]		,     dim=-1)
         else:
              lowercase__					:     List[Any]   = torch.cat([torch.sin(a), torch.cos(a)]		,     dim=-1)
         return out



class    SCREAMING_SNAKE_CASE__      (nn.Module  ):





    def __init__(   self		,     a		,     a		,     a		,     a		,     ):
         super().__init__()

         lowercase__					:     Tuple   = height
         lowercase__					:     Optional[int]   = width
         lowercase__					:     Dict   = num_embed
         lowercase__					:     str   = embed_dim

         lowercase__					:     str   = nn.Embedding(self.num_embed		,     a)
         lowercase__					:     Dict   = nn.Embedding(self.height		,     a)
         lowercase__					:     List[Any]   = nn.Embedding(self.width		,     a)





    def    snake_case_       (   self		,     a):
         lowercase__					:     str   = self.emb(a)

         lowercase__					:     Optional[Any]   = self.height_emb(torch.arange(self.height		,     device=index.device).view(1		,     self.height))

         # 1 x H x D -> 1 x H x 1 x D
         lowercase__					:     str   = height_emb.unsqueeze(2)

         lowercase__					:     List[str]   = self.width_emb(torch.arange(self.width		,     device=index.device).view(1		,     self.width))

         # 1 x W x D -> 1 x 1 x W x D
         lowercase__					:     str   = width_emb.unsqueeze(1)

         lowercase__					:     Optional[int]   = height_emb + width_emb

         # 1 x H x W x D -> 1 x L xD
         lowercase__					:     List[Any]   = pos_emb.view(1		,     self.height * self.width		,     -1)

         lowercase__					:     Dict   = emb + pos_emb[:, : emb.shape[1], :]

         return emb



class    SCREAMING_SNAKE_CASE__      (nn.Module  ):





    def __init__(   self		,     a		,     a		,     a):
         super().__init__()
         lowercase__					:     Optional[int]   = dropout_prob > 0
         lowercase__					:     Dict   = nn.Embedding(num_classes + use_cfg_embedding		,     a)
         lowercase__					:     Dict   = num_classes
         lowercase__					:     Union[str, Any]   = dropout_prob





    def    snake_case_       (   self		,     a		,     a=None):
         if force_drop_ids is None:
              lowercase__					:     List[str]   = torch.rand(labels.shape[0]		,     device=labels.device) < self.dropout_prob
         else:
              lowercase__					:     str   = torch.tensor(force_drop_ids == 1)
         lowercase__					:     Optional[int]   = torch.where(a		,     self.num_classes		,     a)
         return labels





    def    snake_case_       (   self		,     a		,     a=None):
         lowercase__					:     Optional[int]   = self.dropout_prob > 0
         if (self.training and use_dropout) or (force_drop_ids is not None):
              lowercase__					:     Union[str, Any]   = self.token_drop(a		,     a)
         lowercase__					:     Optional[int]   = self.embedding_table(a)
         return embeddings



class    SCREAMING_SNAKE_CASE__      (nn.Module  ):





    def __init__(   self		,     a = 1024		,     a = 768		,     a = 768		,     a = 10		,     ):
         super().__init__()

         lowercase__					:     int   = num_image_text_embeds
         lowercase__					:     int   = nn.Linear(a		,     self.num_image_text_embeds * cross_attention_dim)
         lowercase__					:     Union[str, Any]   = nn.Linear(a		,     a)





    def    snake_case_       (   self		,     a		,     a):
         lowercase__					:     int   = text_embeds.shape[0]

         # image
         lowercase__					:     str   = self.image_embeds(a)
         lowercase__					:     Any   = image_text_embeds.reshape(a		,     self.num_image_text_embeds		,     -1)

         # text
         lowercase__					:     List[str]   = self.text_proj(a)

         return torch.cat([image_text_embeds, text_embeds]		,     dim=1)



class    SCREAMING_SNAKE_CASE__      (nn.Module  ):





    def __init__(   self		,     a = 768		,     a = 768		,     a = 32		,     ):
         super().__init__()

         lowercase__					:     Union[str, Any]   = num_image_text_embeds
         lowercase__					:     Optional[int]   = nn.Linear(a		,     self.num_image_text_embeds * cross_attention_dim)
         lowercase__					:     List[str]   = nn.LayerNorm(a)





    def    snake_case_       (   self		,     a):
         lowercase__					:     Dict   = image_embeds.shape[0]

         # image
         lowercase__					:     int   = self.image_embeds(a)
         lowercase__					:     Optional[int]   = image_embeds.reshape(a		,     self.num_image_text_embeds		,     -1)
         lowercase__					:     List[Any]   = self.norm(a)
         return image_embeds



class    SCREAMING_SNAKE_CASE__      (nn.Module  ):





    def __init__(   self		,     a		,     a		,     a=0.1):
         super().__init__()

         lowercase__					:     str   = Timesteps(num_channels=256		,     flip_sin_to_cos=a		,     downscale_freq_shift=1)
         lowercase__					:     Tuple   = TimestepEmbedding(in_channels=256		,     time_embed_dim=a)
         lowercase__					:     Tuple   = LabelEmbedding(a		,     a		,     a)





    def    snake_case_       (   self		,     a		,     a		,     a=None):
         lowercase__					:     int   = self.time_proj(a)
         lowercase__					:     int   = self.timestep_embedder(timesteps_proj.to(dtype=a))  # (N, D)

         lowercase__					:     Tuple   = self.class_embedder(a)  # (N, D)

         lowercase__					:     List[str]   = timesteps_emb + class_labels  # (N, D)

         return conditioning



class    SCREAMING_SNAKE_CASE__      (nn.Module  ):





    def __init__(   self		,     a		,     a		,     a = 64):
         super().__init__()
         lowercase__					:     List[Any]   = nn.LayerNorm(a)
         lowercase__					:     str   = AttentionPooling(a		,     a)
         lowercase__					:     int   = nn.Linear(a		,     a)
         lowercase__					:     List[str]   = nn.LayerNorm(a)





    def    snake_case_       (   self		,     a):
         lowercase__					:     str   = self.norma(a)
         lowercase__					:     str   = self.pool(a)
         lowercase__					:     int   = self.proj(a)
         lowercase__					:     str   = self.norma(a)
         return hidden_states



class    SCREAMING_SNAKE_CASE__      (nn.Module  ):





    def __init__(   self		,     a = 768		,     a = 768		,     a = 1536):
         super().__init__()
         lowercase__					:     Tuple   = nn.Linear(a		,     a)
         lowercase__					:     Union[str, Any]   = nn.LayerNorm(a)
         lowercase__					:     int   = nn.Linear(a		,     a)





    def    snake_case_       (   self		,     a		,     a):
         # text
         lowercase__					:     str   = self.text_proj(a)
         lowercase__					:     Union[str, Any]   = self.text_norm(a)

         # image
         lowercase__					:     Tuple   = self.image_proj(a)

         return time_image_embeds + time_text_embeds



class    SCREAMING_SNAKE_CASE__      (nn.Module  ):





    def __init__(   self		,     a = 768		,     a = 1536):
         super().__init__()
         lowercase__					:     Any   = nn.Linear(a		,     a)
         lowercase__					:     Union[str, Any]   = nn.LayerNorm(a)





    def    snake_case_       (   self		,     a):
         # image
         lowercase__					:     Any   = self.image_proj(a)
         lowercase__					:     Union[str, Any]   = self.image_norm(a)
         return time_image_embeds



class    SCREAMING_SNAKE_CASE__      (nn.Module  ):





    def __init__(   self		,     a = 768		,     a = 1536):
         super().__init__()
         lowercase__					:     Tuple   = nn.Linear(a		,     a)
         lowercase__					:     str   = nn.LayerNorm(a)
         lowercase__					:     int   = nn.Sequential(
             nn.Convad(3		,     16		,     3		,     padding=1)		,     nn.SiLU()		,     nn.Convad(16		,     16		,     3		,     padding=1)		,     nn.SiLU()		,     nn.Convad(16		,     32		,     3		,     padding=1		,     stride=2)		,     nn.SiLU()		,     nn.Convad(32		,     32		,     3		,     padding=1)		,     nn.SiLU()		,     nn.Convad(32		,     96		,     3		,     padding=1		,     stride=2)		,     nn.SiLU()		,     nn.Convad(96		,     96		,     3		,     padding=1)		,     nn.SiLU()		,     nn.Convad(96		,     256		,     3		,     padding=1		,     stride=2)		,     nn.SiLU()		,     nn.Convad(256		,     4		,     3		,     padding=1)		,     )





    def    snake_case_       (   self		,     a		,     a):
         # image
         lowercase__					:     Optional[Any]   = self.image_proj(a)
         lowercase__					:     Optional[Any]   = self.image_norm(a)
         lowercase__					:     List[Any]   = self.input_hint_block(a)
         return time_image_embeds, hint



class    SCREAMING_SNAKE_CASE__      (nn.Module  ):





    def __init__(   self		,     a		,     a		,     a=None):
         super().__init__()
         lowercase__					:     int   = dtype
         lowercase__					:     List[Any]   = nn.Parameter(torch.randn(1		,     a) / embed_dim**0.5)
         lowercase__					:     List[Any]   = nn.Linear(a		,     a		,     dtype=self.dtype)
         lowercase__					:     str   = nn.Linear(a		,     a		,     dtype=self.dtype)
         lowercase__					:     Tuple   = nn.Linear(a		,     a		,     dtype=self.dtype)
         lowercase__					:     int   = num_heads
         lowercase__					:     Dict   = embed_dim // self.num_heads





    def    snake_case_       (   self		,     a):
         lowercase__					:     str   = x.size()

         def shape(a):
              # (bs, length, width) --> (bs, length, n_heads, dim_per_head)
              lowercase__					:     List[Any]   = x.view(a		,     -1		,     self.num_heads		,     self.dim_per_head)
              # (bs, length, n_heads, dim_per_head) --> (bs, n_heads, length, dim_per_head)
              lowercase__					:     Optional[int]   = x.transpose(1		,     2)
              # (bs, n_heads, length, dim_per_head) --> (bs*n_heads, length, dim_per_head)
              lowercase__					:     str   = x.reshape(bs * self.num_heads		,     -1		,     self.dim_per_head)
              # (bs*n_heads, length, dim_per_head) --> (bs*n_heads, dim_per_head, length)
              lowercase__					:     Tuple   = x.transpose(1		,     2)
              return x

         lowercase__					:     Optional[Any]   = x.mean(dim=1		,     keepdim=a) + self.positional_embedding.to(x.dtype)
         lowercase__					:     Union[str, Any]   = torch.cat([class_token, x]		,     dim=1)  # (bs, length+1, width)

         # (bs*n_heads, class_token_length, dim_per_head)
         lowercase__					:     Union[str, Any]   = shape(self.q_proj(a))
         # (bs*n_heads, length+class_token_length, dim_per_head)
         lowercase__					:     List[str]   = shape(self.k_proj(a))
         lowercase__					:     List[Any]   = shape(self.v_proj(a))

         # (bs*n_heads, class_token_length, length+class_token_length):
         lowercase__					:     Union[str, Any]   = 1 / math.sqrt(math.sqrt(self.dim_per_head))
         lowercase__					:     int   = torch.einsum('bct,bcs->bts'		,     q * scale		,     k * scale)  # More stable with f16 than dividing afterwards
         lowercase__					:     Tuple   = torch.softmax(weight.float()		,     dim=-1).type(weight.dtype)

         # (bs*n_heads, dim_per_head, class_token_length)
         lowercase__					:     Union[str, Any]   = torch.einsum('bts,bcs->bct'		,     a		,     a)

         # (bs, length+1, width)
         lowercase__					:     str   = a.reshape(a		,     -1		,     1).transpose(1		,     2)

         return a[:, 0, :]  # cls_token




from dataclasses import dataclass
from typing import List, Optional, Union

import numpy as np
import PIL

from ...utils import BaseOutput, is_invisible_watermark_available, is_torch_available, is_transformers_available


@dataclass
class    SCREAMING_SNAKE_CASE__      (__snake_case  ):
    __lowerCamelCase		: Union[List[PIL.Image.Image], np.ndarray]


if is_transformers_available() and is_torch_available() and is_invisible_watermark_available():
       from .pipeline_stable_diffusion_xl import StableDiffusionXLPipeline
       from .pipeline_stable_diffusion_xl_imgaimg import StableDiffusionXLImgaImgPipeline

