





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   __snake_case				(			_a   ):






    '''simple docstring'''
    _lowerCAmelCase     =	42


class   __snake_case				(			_a       ,				_a   ):






    '''simple docstring'''





    @register_to_config
    def __init__(   self						:		Dict			,						snake_case						:		int = 16			,						snake_case						:		int = 88			,						snake_case						:		Optional[int] = None			,						snake_case						:		Optional[int] = None			,						snake_case						:		int = 1			,						snake_case						:		float = 0.0			,						snake_case						:		int = 32			,						snake_case						:		Optional[int] = None			,						snake_case						:		bool = False			,						snake_case						:		Optional[int] = None			,						snake_case						:		Optional[int] = None			,						snake_case						:		Optional[int] = None			,						snake_case						:		str = "geglu"			,						snake_case						:		Optional[int] = None			,						snake_case						:		bool = False			,						snake_case						:		bool = False			,						snake_case						:		bool = False			,						snake_case						:		str = "layer_norm"			,						snake_case						:		bool = True			,						):

      """simple docstring"""





      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'''			,						snake_case			,						standard_warn=snake_case							)
        __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=snake_case			,						num_channels=snake_case			,						eps=1e-6			,						affine=snake_case							)
        if use_linear_projection:
          __lowerCAmelCase			=				nn.Linear(snake_case			,						snake_case							)
        else:
          __lowerCAmelCase			=				nn.Convad(snake_case			,						snake_case			,						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=snake_case			,						embed_dim=snake_case			,						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=snake_case			,						width=snake_case			,						patch_size=snake_case			,						in_channels=snake_case			,						embed_dim=snake_case			,						)

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

      # 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(snake_case			,						snake_case							)
        else:
          __lowerCAmelCase			=				nn.Convad(snake_case			,						snake_case			,						kernel_size=1			,						stride=1			,						padding=0							)
      elif self.is_input_vectorized:
        __lowerCAmelCase			=				nn.LayerNorm(snake_case							)
        __lowerCAmelCase			=				nn.Linear(snake_case			,						self.num_vector_embeds - 1							)
      elif self.is_input_patches:
        __lowerCAmelCase			=				nn.LayerNorm(snake_case			,						elementwise_affine=snake_case			,						eps=1e-6							)
        __lowerCAmelCase			=				nn.Linear(snake_case			,						2 * inner_dim							)
        __lowerCAmelCase			=				nn.Linear(snake_case			,						patch_size * patch_size * self.out_channels							)





    def 	A		(   self						:		Tuple			,						snake_case						:		torch.Tensor			,						snake_case						:		Optional[torch.Tensor] = None			,						snake_case						:		Optional[torch.LongTensor] = None			,						snake_case						:		Optional[torch.LongTensor] = None			,						snake_case						:		Dict[str, Any] = None			,						snake_case						:		Optional[torch.Tensor] = None			,						snake_case						:		Optional[torch.Tensor] = None			,						snake_case						:		bool = True			,						):

      """simple docstring"""





      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							)) * -10_000.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							)) * -10_000.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(snake_case							)
        if not self.use_linear_projection:
          __lowerCAmelCase			=				self.proj_in(snake_case							)
          __lowerCAmelCase			=				hidden_states.shape[1]
          __lowerCAmelCase			=				hidden_states.permute(0			,						2			,						3			,						1							).reshape(snake_case			,						height * width			,						snake_case							)
        else:
          __lowerCAmelCase			=				hidden_states.shape[1]
          __lowerCAmelCase			=				hidden_states.permute(0			,						2			,						3			,						1							).reshape(snake_case			,						height * width			,						snake_case							)
          __lowerCAmelCase			=				self.proj_in(snake_case							)
      elif self.is_input_vectorized:
        __lowerCAmelCase			=				self.latent_image_embedding(snake_case							)
      elif self.is_input_patches:
        __lowerCAmelCase			=				self.pos_embed(snake_case							)

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

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

        __lowerCAmelCase			=				hidden_states + residual
      elif self.is_input_vectorized:
        __lowerCAmelCase			=				self.norm_out(snake_case							)
        __lowerCAmelCase			=				self.out(snake_case							)
        # (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(
            snake_case			,						snake_case			,						hidden_dtype=hidden_states.dtype							)
        __lowerCAmelCase	,						__lowerCAmelCase			=				self.proj_out_a(F.silu(snake_case							)							).chunk(2			,						dim=1							)
        __lowerCAmelCase			=				self.norm_out(snake_case							) * (1 + scale[:, None]) + shift[:, None]
        __lowerCAmelCase			=				self.proj_out_a(snake_case							)

        # 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'''			,						snake_case							)
        __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=snake_case							)







import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
      import torch

if is_vision_available():
      from PIL import Image

      from transformers import ViltImageProcessor

class   __snake_case				(			unittest.TestCase   ):






    '''simple docstring'''





    def __init__(   self						:		Tuple			,						snake_case						:		List[str]			,						snake_case						:		Dict=7			,						snake_case						:		str=3			,						snake_case						:		Union[str, Any]=18			,						snake_case						:		str=30			,						snake_case						:		str=400			,						snake_case						:		Optional[Any]=True			,						snake_case						:		List[str]=None			,						snake_case						:		Tuple=2			,						snake_case						:		Dict=True			,						snake_case						:		Dict=[0.5, 0.5, 0.5]			,						snake_case						:		Tuple=[0.5, 0.5, 0.5]			,						):

      """simple docstring"""





      __lowerCAmelCase			=				size if size is not None else {'''shortest_edge''': 30}
      __lowerCAmelCase			=				parent
      __lowerCAmelCase			=				batch_size
      __lowerCAmelCase			=				num_channels
      __lowerCAmelCase			=				image_size
      __lowerCAmelCase			=				min_resolution
      __lowerCAmelCase			=				max_resolution
      __lowerCAmelCase			=				do_resize
      __lowerCAmelCase			=				size
      __lowerCAmelCase			=				size_divisor
      __lowerCAmelCase			=				do_normalize
      __lowerCAmelCase			=				image_mean
      __lowerCAmelCase			=				image_std





    def 	A		(   self						:		int							):

      """simple docstring"""





      return {
          "image_mean": self.image_mean,
          "image_std": self.image_std,
          "do_normalize": self.do_normalize,
          "do_resize": self.do_resize,
          "size": self.size,
          "size_divisor": self.size_divisor,
      }





    def 	A		(   self						:		Dict			,						snake_case						:		List[Any]			,						snake_case						:		Any=False							):

      """simple docstring"""





      if not batched:
        __lowerCAmelCase			=				self.size['''shortest_edge''']
        __lowerCAmelCase			=				image_inputs[0]
        if isinstance(snake_case			,						Image.Image							):
          __lowerCAmelCase	,						__lowerCAmelCase			=				image.size
        else:
          __lowerCAmelCase	,						__lowerCAmelCase			=				image.shape[1], image.shape[2]
        __lowerCAmelCase			=				size / min(snake_case			,						snake_case							)
        if h < w:
          __lowerCAmelCase	,						__lowerCAmelCase			=				size, scale * w
        else:
          __lowerCAmelCase	,						__lowerCAmelCase			=				scale * h, size

        __lowerCAmelCase			=				int((1_333 / 800) * size							)
        if max(snake_case			,						snake_case							) > max_size:
          __lowerCAmelCase			=				max_size / max(snake_case			,						snake_case							)
          __lowerCAmelCase			=				newh * scale
          __lowerCAmelCase			=				neww * scale

        __lowerCAmelCase	,						__lowerCAmelCase			=				int(newh + 0.5							), int(neww + 0.5							)
        __lowerCAmelCase	,						__lowerCAmelCase			=				(
            newh // self.size_divisor * self.size_divisor,
            neww // self.size_divisor * self.size_divisor,
        )

      else:
        __lowerCAmelCase			=				[]
        for image in image_inputs:
          __lowerCAmelCase	,						__lowerCAmelCase			=				self.get_expected_values([image]							)
          expected_values.append((expected_height, expected_width)							)
        __lowerCAmelCase			=				max(snake_case			,						key=lambda snake_case							: item[0]							)[0]
        __lowerCAmelCase			=				max(snake_case			,						key=lambda snake_case							: item[1]							)[1]

      return expected_height, expected_width


@require_torch
@require_vision
class   __snake_case				(			_a       ,				unittest.TestCase   ):






    '''simple docstring'''
    _lowerCAmelCase     =	ViltImageProcessor if is_vision_available() else None





    def 	A		(   self						:		Union[str, Any]							):

      """simple docstring"""





      __lowerCAmelCase			=				ViltImageProcessingTester(self							)





    @property
    def 	A		(   self						:		Any							):

      """simple docstring"""





      return self.image_processor_tester.prepare_image_processor_dict()





    def 	A		(   self						:		List[Any]							):

      """simple docstring"""





      __lowerCAmelCase			=				self.image_processing_class(**self.image_processor_dict							)
      self.assertTrue(hasattr(snake_case			,						'''image_mean'''							)							)
      self.assertTrue(hasattr(snake_case			,						'''image_std'''							)							)
      self.assertTrue(hasattr(snake_case			,						'''do_normalize'''							)							)
      self.assertTrue(hasattr(snake_case			,						'''do_resize'''							)							)
      self.assertTrue(hasattr(snake_case			,						'''size'''							)							)
      self.assertTrue(hasattr(snake_case			,						'''size_divisor'''							)							)





    def 	A		(   self						:		Optional[Any]							):

      """simple docstring"""





      __lowerCAmelCase			=				self.image_processing_class.from_dict(self.image_processor_dict							)
      self.assertEqual(image_processor.size			,						{'''shortest_edge''': 30}							)

      __lowerCAmelCase			=				self.image_processing_class.from_dict(self.image_processor_dict			,						size=42							)
      self.assertEqual(image_processor.size			,						{'''shortest_edge''': 42}							)





    def 	A		(   self						:		Union[str, Any]							):

      """simple docstring"""





      pass





    def 	A		(   self						:		Union[str, Any]							):

      """simple docstring"""





      __lowerCAmelCase			=				self.image_processing_class(**self.image_processor_dict							)
      # create random PIL images
      __lowerCAmelCase			=				prepare_image_inputs(self.image_processor_tester			,						equal_resolution=snake_case							)
      for image in image_inputs:
        self.assertIsInstance(snake_case			,						Image.Image							)

      # Test not batched input
      __lowerCAmelCase			=				image_processing(image_inputs[0]			,						return_tensors='''pt'''							).pixel_values

      __lowerCAmelCase	,						__lowerCAmelCase			=				self.image_processor_tester.get_expected_values(snake_case							)
      self.assertEqual(
          encoded_images.shape			,						(1, self.image_processor_tester.num_channels, expected_height, expected_width)			,						)

      # Test batched
      __lowerCAmelCase			=				image_processing(snake_case			,						return_tensors='''pt'''							).pixel_values

      __lowerCAmelCase	,						__lowerCAmelCase			=				self.image_processor_tester.get_expected_values(snake_case			,						batched=snake_case							)
      self.assertEqual(
          encoded_images.shape			,						(
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              expected_height,
              expected_width,
          )			,						)





    def 	A		(   self						:		Tuple							):

      """simple docstring"""





      __lowerCAmelCase			=				self.image_processing_class(**self.image_processor_dict							)
      # create random numpy tensors
      __lowerCAmelCase			=				prepare_image_inputs(self.image_processor_tester			,						equal_resolution=snake_case			,						numpify=snake_case							)
      for image in image_inputs:
        self.assertIsInstance(snake_case			,						np.ndarray							)

      # Test not batched input
      __lowerCAmelCase			=				image_processing(image_inputs[0]			,						return_tensors='''pt'''							).pixel_values

      __lowerCAmelCase	,						__lowerCAmelCase			=				self.image_processor_tester.get_expected_values(snake_case							)
      self.assertEqual(
          encoded_images.shape			,						(1, self.image_processor_tester.num_channels, expected_height, expected_width)			,						)

      # Test batched
      __lowerCAmelCase			=				image_processing(snake_case			,						return_tensors='''pt'''							).pixel_values

      __lowerCAmelCase	,						__lowerCAmelCase			=				self.image_processor_tester.get_expected_values(snake_case			,						batched=snake_case							)
      self.assertEqual(
          encoded_images.shape			,						(
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              expected_height,
              expected_width,
          )			,						)





    def 	A		(   self						:		List[str]							):

      """simple docstring"""





      __lowerCAmelCase			=				self.image_processing_class(**self.image_processor_dict							)
      # create random PyTorch tensors
      __lowerCAmelCase			=				prepare_image_inputs(self.image_processor_tester			,						equal_resolution=snake_case			,						torchify=snake_case							)
      for image in image_inputs:
        self.assertIsInstance(snake_case			,						torch.Tensor							)

      # Test not batched input
      __lowerCAmelCase			=				image_processing(image_inputs[0]			,						return_tensors='''pt'''							).pixel_values

      __lowerCAmelCase	,						__lowerCAmelCase			=				self.image_processor_tester.get_expected_values(snake_case							)
      self.assertEqual(
          encoded_images.shape			,						(1, self.image_processor_tester.num_channels, expected_height, expected_width)			,						)

      # Test batched
      __lowerCAmelCase			=				image_processing(snake_case			,						return_tensors='''pt'''							).pixel_values

      __lowerCAmelCase	,						__lowerCAmelCase			=				self.image_processor_tester.get_expected_values(snake_case			,						batched=snake_case							)
      self.assertEqual(
          encoded_images.shape			,						(
              self.image_processor_tester.batch_size,
              self.image_processor_tester.num_channels,
              expected_height,
              expected_width,
          )			,						)
