




from dataclasses import dataclass
from typing import Any, Dict, Optional

import torch
import torch.nn.functional as F
from torch import nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..models.embeddings import ImagePositionalEmbeddings
from ..utils import BaseOutput, deprecate
from .attention import BasicTransformerBlock
from .embeddings import PatchEmbed
from .modeling_utils import ModelMixin


@dataclass
class 			A			(		_UpperCAmelCase		):
     """simple docstring"""

     _snake_case:	Union[str, Any]     =42


class 			A			(		_UpperCAmelCase			,						_UpperCAmelCase		):
     """simple docstring"""

     @register_to_config
     def __init__(    self  :   List[str]	,  A__  :   int = 1_6	,  A__  :   Union[str, Any] = 8_8	,  A__  :   Any = None	,  A__  :   str = None	,  A__  :   List[Any] = 1	,  A__  :   Optional[int] = 0.0	,  A__  :   int = 3_2	,  A__  :   Dict = None	,  A__  :   List[str] = False	,  A__  :   Union[str, Any] = None	,  A__  :   List[Any] = None	,  A__  :   List[Any] = None	,  A__  :   Any = "geglu"	,  A__  :   Tuple = None	,  A__  :   Any = False	,  A__  :   Optional[int] = False	,  A__  :   Optional[Any] = False	,  A__  :   Union[str, Any] = "layer_norm"	,  A__  :   List[str] = True	,  )				->       Any:
           super().__init__()
           lowerCamelCase__        =				use_linear_projection
           lowerCamelCase__        =				num_attention_heads
           lowerCamelCase__        =				attention_head_dim
           lowerCamelCase__        =				num_attention_heads * attention_head_dim

           # 1. Transformer2DModel can process both standard continuous images of shape `(batch_size, num_channels, width, height)` as well as quantized image embeddings of shape `(batch_size, num_image_vectors)`
           # Define whether input is continuous or discrete depending on configuration
           lowerCamelCase__        =				(in_channels is not None) and (patch_size is None)
           lowerCamelCase__        =				num_vector_embeds is not None
           lowerCamelCase__        =				in_channels is not None and patch_size is not None

           if norm_type == "layer_norm" and num_embeds_ada_norm is not None:
                 lowerCamelCase__        =				(
                     F"""The configuration file of this model: {self.__class__} is outdated. `norm_type` is either not set or"""
                     ' incorrectly set to `\'layer_norm\'`.Make sure to set `norm_type` to `\'ada_norm\'` in the config.'
                     ' Please make sure to update the config accordingly as leaving `norm_type` might led to incorrect'
                     ' results in future versions. If you have downloaded this checkpoint from the Hugging Face Hub, it'
                     ' would be very nice if you could open a Pull request for the `transformer/config.json` file'
                 )
                 deprecate('norm_type!=num_embeds_ada_norm'	,  '1.0.0'	,  A__	,  standard_warn=A__			)
                 lowerCamelCase__        =				'ada_norm'

           if self.is_input_continuous and self.is_input_vectorized:
                 raise ValueError(
                     F"""Cannot define both `in_channels`: {in_channels} and `num_vector_embeds`: {num_vector_embeds}. Make"""
                     ' sure that either `in_channels` or `num_vector_embeds` is None.'			)
           elif self.is_input_vectorized and self.is_input_patches:
                 raise ValueError(
                     F"""Cannot define both `num_vector_embeds`: {num_vector_embeds} and `patch_size`: {patch_size}. Make"""
                     ' sure that either `num_vector_embeds` or `num_patches` is None.'			)
           elif not self.is_input_continuous and not self.is_input_vectorized and not self.is_input_patches:
                 raise ValueError(
                     F"""Has to define `in_channels`: {in_channels}, `num_vector_embeds`: {num_vector_embeds}, or patch_size:"""
                     F""" {patch_size}. Make sure that `in_channels`, `num_vector_embeds` or `num_patches` is not None."""			)

           # 2. Define input layers
           if self.is_input_continuous:
                 lowerCamelCase__        =				in_channels

                 lowerCamelCase__        =				torch.nn.GroupNorm(num_groups=A__	,  num_channels=A__	,  eps=1E-6	,  affine=A__			)
                 if use_linear_projection:
                       lowerCamelCase__        =				nn.Linear(A__	,  A__			)
                 else:
                       lowerCamelCase__        =				nn.Convad(A__	,  A__	,  kernel_size=1	,  stride=1	,  padding=0			)
           elif self.is_input_vectorized:
                 assert sample_size is not None, "Transformer2DModel over discrete input must provide sample_size"
                 assert num_vector_embeds is not None, "Transformer2DModel over discrete input must provide num_embed"

                 lowerCamelCase__        =				sample_size
                 lowerCamelCase__        =				sample_size
                 lowerCamelCase__        =				num_vector_embeds
                 lowerCamelCase__        =				self.height * self.width

                 lowerCamelCase__        =				ImagePositionalEmbeddings(
                     num_embed=A__	,  embed_dim=A__	,  height=self.height	,  width=self.width			)
           elif self.is_input_patches:
                 assert sample_size is not None, "Transformer2DModel over patched input must provide sample_size"

                 lowerCamelCase__        =				sample_size
                 lowerCamelCase__        =				sample_size

                 lowerCamelCase__        =				patch_size
                 lowerCamelCase__        =				PatchEmbed(
                     height=A__	,  width=A__	,  patch_size=A__	,  in_channels=A__	,  embed_dim=A__	,  )

           # 3. Define transformers blocks
           lowerCamelCase__        =				nn.ModuleList(
               [
                   BasicTransformerBlock(
                       A__	,  A__	,  A__	,  dropout=A__	,  cross_attention_dim=A__	,  activation_fn=A__	,  num_embeds_ada_norm=A__	,  attention_bias=A__	,  only_cross_attention=A__	,  upcast_attention=A__	,  norm_type=A__	,  norm_elementwise_affine=A__	,  )
                   for d in range(A__			)
               ]			)

           # 4. Define output layers
           lowerCamelCase__        =				in_channels if out_channels is None else out_channels
           if self.is_input_continuous:
                 # TODO: should use out_channels for continuous projections
                 if use_linear_projection:
                       lowerCamelCase__        =				nn.Linear(A__	,  A__			)
                 else:
                       lowerCamelCase__        =				nn.Convad(A__	,  A__	,  kernel_size=1	,  stride=1	,  padding=0			)
           elif self.is_input_vectorized:
                 lowerCamelCase__        =				nn.LayerNorm(A__			)
                 lowerCamelCase__        =				nn.Linear(A__	,  self.num_vector_embeds - 1			)
           elif self.is_input_patches:
                 lowerCamelCase__        =				nn.LayerNorm(A__	,  elementwise_affine=A__	,  eps=1E-6			)
                 lowerCamelCase__        =				nn.Linear(A__	,  2 * inner_dim			)
                 lowerCamelCase__        =				nn.Linear(A__	,  patch_size * patch_size * self.out_channels			)




     def  __snake_case   (    self  :   int	,  A__  :   List[str]	,  A__  :   List[str] = None	,  A__  :   Optional[Any] = None	,  A__  :   Tuple = None	,  A__  :   Dict = None	,  A__  :   Dict = None	,  A__  :   str = None	,  A__  :   int = True	,  )				->       List[str]:






           if attention_mask is not None and attention_mask.ndim == 2:
                 # assume that mask is expressed as:
                 #   (1 = keep,      0 = discard)
                 # convert mask into a bias that can be added to attention scores:
                 #       (keep = +0,     discard = -10000.0)
                 lowerCamelCase__        =				(1 - attention_mask.to(hidden_states.dtype			)) * -1_0_0_0_0.0
                 lowerCamelCase__        =				attention_mask.unsqueeze(1			)

           # convert encoder_attention_mask to a bias the same way we do for attention_mask
           if encoder_attention_mask is not None and encoder_attention_mask.ndim == 2:
                 lowerCamelCase__        =				(1 - encoder_attention_mask.to(hidden_states.dtype			)) * -1_0_0_0_0.0
                 lowerCamelCase__        =				encoder_attention_mask.unsqueeze(1			)

           # 1. Input
           if self.is_input_continuous:
                 lowerCamelCase__  ,		lowerCamelCase__  ,		lowerCamelCase__  ,		lowerCamelCase__        =				hidden_states.shape
                 lowerCamelCase__        =				hidden_states

                 lowerCamelCase__        =				self.norm(A__			)
                 if not self.use_linear_projection:
                       lowerCamelCase__        =				self.proj_in(A__			)
                       lowerCamelCase__        =				hidden_states.shape[1]
                       lowerCamelCase__        =				hidden_states.permute(0	,  2	,  3	,  1			).reshape(A__	,  height * width	,  A__			)
                 else:
                       lowerCamelCase__        =				hidden_states.shape[1]
                       lowerCamelCase__        =				hidden_states.permute(0	,  2	,  3	,  1			).reshape(A__	,  height * width	,  A__			)
                       lowerCamelCase__        =				self.proj_in(A__			)
           elif self.is_input_vectorized:
                 lowerCamelCase__        =				self.latent_image_embedding(A__			)
           elif self.is_input_patches:
                 lowerCamelCase__        =				self.pos_embed(A__			)

           # 2. Blocks
           for block in self.transformer_blocks:
                 lowerCamelCase__        =				block(
                     A__	,  attention_mask=A__	,  encoder_hidden_states=A__	,  encoder_attention_mask=A__	,  timestep=A__	,  cross_attention_kwargs=A__	,  class_labels=A__	,  )

           # 3. Output
           if self.is_input_continuous:
                 if not self.use_linear_projection:
                       lowerCamelCase__        =				hidden_states.reshape(A__	,  A__	,  A__	,  A__			).permute(0	,  3	,  1	,  2			).contiguous()
                       lowerCamelCase__        =				self.proj_out(A__			)
                 else:
                       lowerCamelCase__        =				self.proj_out(A__			)
                       lowerCamelCase__        =				hidden_states.reshape(A__	,  A__	,  A__	,  A__			).permute(0	,  3	,  1	,  2			).contiguous()

                 lowerCamelCase__        =				hidden_states + residual
           elif self.is_input_vectorized:
                 lowerCamelCase__        =				self.norm_out(A__			)
                 lowerCamelCase__        =				self.out(A__			)
                 # (batch, self.num_vector_embeds - 1, self.num_latent_pixels)
                 lowerCamelCase__        =				logits.permute(0	,  2	,  1			)

                 # log(p(x_0))
                 lowerCamelCase__        =				F.log_softmax(logits.double()	,  dim=1			).float()
           elif self.is_input_patches:
                 # TODO: cleanup!
                 lowerCamelCase__        =				self.transformer_blocks[0].norma.emb(
                     A__	,  A__	,  hidden_dtype=hidden_states.dtype			)
                 lowerCamelCase__  ,		lowerCamelCase__        =				self.proj_out_a(F.silu(A__			)			).chunk(2	,  dim=1			)
                 lowerCamelCase__        =				self.norm_out(A__			) * (1 + scale[:, None]) + shift[:, None]
                 lowerCamelCase__        =				self.proj_out_a(A__			)

                 # unpatchify
                 lowerCamelCase__        =				lowerCamelCase__        =				int(hidden_states.shape[1] ** 0.5			)
                 lowerCamelCase__        =				hidden_states.reshape(
                     shape=(-1, height, width, self.patch_size, self.patch_size, self.out_channels)			)
                 lowerCamelCase__        =				torch.einsum('nhwpqc->nchpwq'	,  A__			)
                 lowerCamelCase__        =				hidden_states.reshape(
                     shape=(-1, self.out_channels, height * self.patch_size, width * self.patch_size)			)

           if not return_dict:
                 return (output,)

           return TransformeraDModelOutput(sample=A__			)





from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    get_resize_output_image_size,
    normalize,
    pad,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    get_image_size,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging
from ...utils.import_utils import is_vision_available


__SCREAMING_SNAKE_CASE    :   Tuple       =logging.get_logger(__name__)


if is_vision_available():
      import PIL






class 			A			(		_lowerCAmelCase		):
     """simple docstring"""

     _snake_case:	Dict     =["pixel_values"]




     def __init__(    self  :   Optional[Any]	,  A__  :   bool = True	,  A__  :   Dict[str, int] = None	,  A__  :   PILImageResampling = PILImageResampling.BILINEAR	,  A__  :   bool = True	,  A__  :   bool = False	,  A__  :   bool = True	,  A__  :   bool = True	,  A__  :   Union[int, float] = 1 / 2_5_5	,  A__  :   bool = True	,  A__  :   Optional[Union[float, List[float]]] = None	,  A__  :   Optional[Union[float, List[float]]] = None	,  **A__  :   List[str]	,  )				->       None:
           super().__init__(**A__			)

           lowerCamelCase__        =				size if size is not None else {'height': 2_5_6_0, 'width': 1_9_2_0}
           if isinstance(A__	,  (tuple, list)			):
                 # The previous feature extractor size parameter was in (width, height) format
                 lowerCamelCase__        =				size[::-1]
           lowerCamelCase__        =				get_size_dict(A__			)

           lowerCamelCase__        =				do_resize
           lowerCamelCase__        =				size
           lowerCamelCase__        =				resample
           lowerCamelCase__        =				do_thumbnail
           lowerCamelCase__        =				do_align_long_axis
           lowerCamelCase__        =				do_pad
           lowerCamelCase__        =				do_rescale
           lowerCamelCase__        =				rescale_factor
           lowerCamelCase__        =				do_normalize
           lowerCamelCase__        =				image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
           lowerCamelCase__        =				image_std if image_std is not None else IMAGENET_STANDARD_STD




     def  __snake_case   (    self  :   str	,  A__  :   np.ndarray	,  A__  :   Dict[str, int]	,  A__  :   Optional[Union[str, ChannelDimension]] = None			)				->       np.ndarray:
           lowerCamelCase__  ,		lowerCamelCase__        =				get_image_size(A__			)
           lowerCamelCase__  ,		lowerCamelCase__        =				size['height'], size['width']

           if (output_width < output_height and input_width > input_height) or (
               output_width > output_height and input_width < input_height
           ):
                 lowerCamelCase__        =				np.rotaa(A__	,  3			)

           if data_format is not None:
                 lowerCamelCase__        =				to_channel_dimension_format(A__	,  A__			)

           return image




     def  __snake_case   (    self  :   Tuple	,  A__  :   np.ndarray	,  A__  :   Dict[str, int]	,  A__  :   bool = False	,  A__  :   Optional[Union[str, ChannelDimension]] = None	,  )				->       np.ndarray:
           lowerCamelCase__  ,		lowerCamelCase__        =				size['height'], size['width']
           lowerCamelCase__  ,		lowerCamelCase__        =				get_image_size(A__			)

           lowerCamelCase__        =				output_width - input_width
           lowerCamelCase__        =				output_height - input_height

           if random_padding:
                 lowerCamelCase__        =				np.random.randint(low=0	,  high=delta_height + 1			)
                 lowerCamelCase__        =				np.random.randint(low=0	,  high=delta_width + 1			)
           else:
                 lowerCamelCase__        =				delta_height // 2
                 lowerCamelCase__        =				delta_width // 2

           lowerCamelCase__        =				delta_height - pad_top
           lowerCamelCase__        =				delta_width - pad_left

           lowerCamelCase__        =				((pad_top, pad_bottom), (pad_left, pad_right))
           return pad(A__	,  A__	,  data_format=A__			)




     def  __snake_case   (    self  :   int	,  *A__  :   Tuple	,  **A__  :   Dict			)				->       List[Any]:
           logger.info('pad is deprecated and will be removed in version 4.27. Please use pad_image instead.'			)
           return self.pad_image(*A__	,  **A__			)




     def  __snake_case   (    self  :   Any	,  A__  :   np.ndarray	,  A__  :   Dict[str, int]	,  A__  :   PILImageResampling = PILImageResampling.BICUBIC	,  A__  :   Optional[Union[str, ChannelDimension]] = None	,  **A__  :   Any	,  )				->       np.ndarray:
           lowerCamelCase__  ,		lowerCamelCase__        =				get_image_size(A__			)
           lowerCamelCase__  ,		lowerCamelCase__        =				size['height'], size['width']

           # We always resize to the smallest of either the input or output size.
           lowerCamelCase__        =				min(A__	,  A__			)
           lowerCamelCase__        =				min(A__	,  A__			)

           if height == input_height and width == input_width:
                 return image

           if input_height > input_width:
                 lowerCamelCase__        =				int(input_width * height / input_height			)
           elif input_width > input_height:
                 lowerCamelCase__        =				int(input_height * width / input_width			)

           return resize(
               A__	,  size=(height, width)	,  resample=A__	,  reducing_gap=2.0	,  data_format=A__	,  **A__			)




     def  __snake_case   (    self  :   List[str]	,  A__  :   np.ndarray	,  A__  :   Dict[str, int]	,  A__  :   PILImageResampling = PILImageResampling.BICUBIC	,  A__  :   Optional[Union[str, ChannelDimension]] = None	,  **A__  :   Any	,  )				->       np.ndarray:
           lowerCamelCase__        =				get_size_dict(A__			)
           lowerCamelCase__        =				min(size['height']	,  size['width']			)
           lowerCamelCase__        =				get_resize_output_image_size(A__	,  size=A__	,  default_to_square=A__			)
           lowerCamelCase__        =				resize(A__	,  size=A__	,  resample=A__	,  data_format=A__	,  **A__			)
           return resized_image




     def  __snake_case   (    self  :   Optional[int]	,  A__  :   np.ndarray	,  A__  :   Union[int, float]	,  A__  :   Optional[Union[str, ChannelDimension]] = None	,  **A__  :   Optional[int]	,  )				->       Tuple:
           return rescale(A__	,  scale=A__	,  data_format=A__	,  **A__			)




     def  __snake_case   (    self  :   Any	,  A__  :   np.ndarray	,  A__  :   Union[float, List[float]]	,  A__  :   Union[float, List[float]]	,  A__  :   Optional[Union[str, ChannelDimension]] = None	,  **A__  :   Union[str, Any]	,  )				->       np.ndarray:
           return normalize(A__	,  mean=A__	,  std=A__	,  data_format=A__	,  **A__			)




     def  __snake_case   (    self  :   Union[str, Any]	,  A__  :   ImageInput	,  A__  :   bool = None	,  A__  :   Dict[str, int] = None	,  A__  :   PILImageResampling = None	,  A__  :   bool = None	,  A__  :   bool = None	,  A__  :   bool = None	,  A__  :   bool = False	,  A__  :   bool = None	,  A__  :   float = None	,  A__  :   bool = None	,  A__  :   Optional[Union[float, List[float]]] = None	,  A__  :   Optional[Union[float, List[float]]] = None	,  A__  :   Optional[Union[str, TensorType]] = None	,  A__  :   Optional[ChannelDimension] = ChannelDimension.FIRST	,  **A__  :   Any	,  )				->       PIL.Image.Image:
           lowerCamelCase__        =				do_resize if do_resize is not None else self.do_resize
           lowerCamelCase__        =				size if size is not None else self.size
           if isinstance(A__	,  (tuple, list)			):
                 # Previous feature extractor had size in (width, height) format
                 lowerCamelCase__        =				size[::-1]
           lowerCamelCase__        =				get_size_dict(A__			)
           lowerCamelCase__        =				resample if resample is not None else self.resample
           lowerCamelCase__        =				do_thumbnail if do_thumbnail is not None else self.do_thumbnail
           lowerCamelCase__        =				do_align_long_axis if do_align_long_axis is not None else self.do_align_long_axis
           lowerCamelCase__        =				do_pad if do_pad is not None else self.do_pad
           lowerCamelCase__        =				do_rescale if do_rescale is not None else self.do_rescale
           lowerCamelCase__        =				rescale_factor if rescale_factor is not None else self.rescale_factor
           lowerCamelCase__        =				do_normalize if do_normalize is not None else self.do_normalize
           lowerCamelCase__        =				image_mean if image_mean is not None else self.image_mean
           lowerCamelCase__        =				image_std if image_std is not None else self.image_std

           lowerCamelCase__        =				make_list_of_images(A__			)

           if not valid_images(A__			):
                 raise ValueError(
                     'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '
                     'torch.Tensor, tf.Tensor or jax.ndarray.'			)

           if do_resize and size is None:
                 raise ValueError('Size must be specified if do_resize is True.'			)

           if do_rescale and rescale_factor is None:
                 raise ValueError('Rescale factor must be specified if do_rescale is True.'			)

           if do_pad and size is None:
                 raise ValueError('Size must be specified if do_pad is True.'			)

           if do_normalize and (image_mean is None or image_std is None):
                 raise ValueError('Image mean and std must be specified if do_normalize is True.'			)

           # All transformations expect numpy arrays.
           lowerCamelCase__        =				[to_numpy_array(A__			) for image in images]

           if do_align_long_axis:
                 lowerCamelCase__        =				[self.align_long_axis(A__	,  size=A__			) for image in images]

           if do_resize:
                 lowerCamelCase__        =				[self.resize(image=A__	,  size=A__	,  resample=A__			) for image in images]

           if do_thumbnail:
                 lowerCamelCase__        =				[self.thumbnail(image=A__	,  size=A__			) for image in images]

           if do_pad:
                 lowerCamelCase__        =				[self.pad_image(image=A__	,  size=A__	,  random_padding=A__			) for image in images]

           if do_rescale:
                 lowerCamelCase__        =				[self.rescale(image=A__	,  scale=A__			) for image in images]

           if do_normalize:
                 lowerCamelCase__        =				[self.normalize(image=A__	,  mean=A__	,  std=A__			) for image in images]

           lowerCamelCase__        =				[to_channel_dimension_format(A__	,  A__			) for image in images]

           lowerCamelCase__        =				{'pixel_values': images}
           return BatchFeature(data=A__	,  tensor_type=A__			)