code: 
  
  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    SCREAMING_SNAKE_CASE__      (a__  ):
      __lowerCamelCase		: torch.FloatTensor
  
  
  
  class    SCREAMING_SNAKE_CASE__      (a__	, a__  ):
  
  
  
  
  
      @register_to_config
      def __init__(   self		,     a = 16		,     a = 88		,     a = None		,     a = None		,     a = 1		,     a = 0.0		,     a = 32		,     a = None		,     a = False		,     a = None		,     a = None		,     a = None		,     a = "geglu"		,     a = None		,     a = False		,     a = False		,     a = False		,     a = "layer_norm"		,     a = True		,     ):
           super().__init__()
           lowercase__					:     Tuple   = use_linear_projection
           lowercase__					:     int   = num_attention_heads
           lowercase__					:     Dict   = attention_head_dim
           lowercase__					:     Optional[int]   = 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
           lowercase__					:     Optional[Any]   = (in_channels is not None) and (patch_size is None)
           lowercase__					:     Tuple   = num_vector_embeds is not None
           lowercase__					:     Optional[int]   = in_channels is not None and patch_size is not None
  
           if norm_type == "layer_norm" and num_embeds_ada_norm is not None:
                lowercase__					:     Any   = (
                    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'		,     SCREAMING_SNAKE_CASE_		,     standard_warn=SCREAMING_SNAKE_CASE_)
                lowercase__					:     Any   = '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:
                lowercase__					:     Optional[int]   = in_channels
  
                lowercase__					:     str   = torch.nn.GroupNorm(num_groups=SCREAMING_SNAKE_CASE_		,     num_channels=SCREAMING_SNAKE_CASE_		,     eps=1e-6		,     affine=SCREAMING_SNAKE_CASE_)
                if use_linear_projection:
                     lowercase__					:     Dict   = nn.Linear(SCREAMING_SNAKE_CASE_		,     SCREAMING_SNAKE_CASE_)
                else:
                     lowercase__					:     Any   = nn.Convad(SCREAMING_SNAKE_CASE_		,     SCREAMING_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"
  
                lowercase__					:     Union[str, Any]   = sample_size
                lowercase__					:     int   = sample_size
                lowercase__					:     Optional[Any]   = num_vector_embeds
                lowercase__					:     str   = self.height * self.width
  
                lowercase__					:     Union[str, Any]   = ImagePositionalEmbeddings(
                    num_embed=SCREAMING_SNAKE_CASE_		,     embed_dim=SCREAMING_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"
  
                lowercase__					:     int   = sample_size
                lowercase__					:     Optional[Any]   = sample_size
  
                lowercase__					:     List[str]   = patch_size
                lowercase__					:     Tuple   = PatchEmbed(
                    height=SCREAMING_SNAKE_CASE_		,     width=SCREAMING_SNAKE_CASE_		,     patch_size=SCREAMING_SNAKE_CASE_		,     in_channels=SCREAMING_SNAKE_CASE_		,     embed_dim=SCREAMING_SNAKE_CASE_		,     )
  
           # 3. Define transformers blocks
           lowercase__					:     Any   = nn.ModuleList(
               [
                   BasicTransformerBlock(
                       SCREAMING_SNAKE_CASE_		,     SCREAMING_SNAKE_CASE_		,     SCREAMING_SNAKE_CASE_		,     dropout=SCREAMING_SNAKE_CASE_		,     cross_attention_dim=SCREAMING_SNAKE_CASE_		,     activation_fn=SCREAMING_SNAKE_CASE_		,     num_embeds_ada_norm=SCREAMING_SNAKE_CASE_		,     attention_bias=SCREAMING_SNAKE_CASE_		,     only_cross_attention=SCREAMING_SNAKE_CASE_		,     upcast_attention=SCREAMING_SNAKE_CASE_		,     norm_type=SCREAMING_SNAKE_CASE_		,     norm_elementwise_affine=SCREAMING_SNAKE_CASE_		,     )
                   for d in range(SCREAMING_SNAKE_CASE_)
               ])
  
           # 4. Define output layers
           lowercase__					:     Optional[int]   = 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:
                     lowercase__					:     Optional[Any]   = nn.Linear(SCREAMING_SNAKE_CASE_		,     SCREAMING_SNAKE_CASE_)
                else:
                     lowercase__					:     List[str]   = nn.Convad(SCREAMING_SNAKE_CASE_		,     SCREAMING_SNAKE_CASE_		,     kernel_size=1		,     stride=1		,     padding=0)
           elif self.is_input_vectorized:
                lowercase__					:     Optional[Any]   = nn.LayerNorm(SCREAMING_SNAKE_CASE_)
                lowercase__					:     Any   = nn.Linear(SCREAMING_SNAKE_CASE_		,     self.num_vector_embeds - 1)
           elif self.is_input_patches:
                lowercase__					:     List[str]   = nn.LayerNorm(SCREAMING_SNAKE_CASE_		,     elementwise_affine=SCREAMING_SNAKE_CASE_		,     eps=1e-6)
                lowercase__					:     Tuple   = nn.Linear(SCREAMING_SNAKE_CASE_		,     2 * inner_dim)
                lowercase__					:     Any   = nn.Linear(SCREAMING_SNAKE_CASE_		,     patch_size * patch_size * self.out_channels)
  
  
  
  
  
      def    snake_case_       (   self		,     a		,     a = None		,     a = None		,     a = None		,     a = None		,     a = None		,     a = None		,     a = True		,     ):
           # ensure attention_mask is a bias, and give it a singleton query_tokens dimension.
           #   we may have done this conversion already, e.g. if we came here via UNet2DConditionModel#forward.
           #   we can tell by counting dims; if ndim == 2: it's a mask rather than a bias.
           # expects mask of shape:
           #   [batch, key_tokens]
           # adds singleton query_tokens dimension:
           #   [batch,                    1, key_tokens]
           # this helps to broadcast it as a bias over attention scores, which will be in one of the following shapes:
           #   [batch,  heads, query_tokens, key_tokens] (e.g. torch sdp attn)
           #   [batch * heads, query_tokens, key_tokens] (e.g. xformers or classic attn)
           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)
                lowercase__					:     List[str]   = (1 - attention_mask.to(hidden_states.dtype)) * -1_0000.0
                lowercase__					:     Tuple   = 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:
                lowercase__					:     int   = (1 - encoder_attention_mask.to(hidden_states.dtype)) * -1_0000.0
                lowercase__					:     Dict   = encoder_attention_mask.unsqueeze(1)
  
           # 1. Input
           if self.is_input_continuous:
                lowercase__					:     Union[str, Any]   = hidden_states.shape
                lowercase__					:     str   = hidden_states
  
                lowercase__					:     Union[str, Any]   = self.norm(SCREAMING_SNAKE_CASE_)
                if not self.use_linear_projection:
                     lowercase__					:     Tuple   = self.proj_in(SCREAMING_SNAKE_CASE_)
                     lowercase__					:     Optional[int]   = hidden_states.shape[1]
                     lowercase__					:     Tuple   = hidden_states.permute(0		,     2		,     3		,     1).reshape(SCREAMING_SNAKE_CASE_		,     height * width		,     SCREAMING_SNAKE_CASE_)
                else:
                     lowercase__					:     Optional[int]   = hidden_states.shape[1]
                     lowercase__					:     Dict   = hidden_states.permute(0		,     2		,     3		,     1).reshape(SCREAMING_SNAKE_CASE_		,     height * width		,     SCREAMING_SNAKE_CASE_)
                     lowercase__					:     Union[str, Any]   = self.proj_in(SCREAMING_SNAKE_CASE_)
           elif self.is_input_vectorized:
                lowercase__					:     Union[str, Any]   = self.latent_image_embedding(SCREAMING_SNAKE_CASE_)
           elif self.is_input_patches:
                lowercase__					:     Any   = self.pos_embed(SCREAMING_SNAKE_CASE_)
  
           # 2. Blocks
           for block in self.transformer_blocks:
                lowercase__					:     Optional[int]   = block(
                    SCREAMING_SNAKE_CASE_		,     attention_mask=SCREAMING_SNAKE_CASE_		,     encoder_hidden_states=SCREAMING_SNAKE_CASE_		,     encoder_attention_mask=SCREAMING_SNAKE_CASE_		,     timestep=SCREAMING_SNAKE_CASE_		,     cross_attention_kwargs=SCREAMING_SNAKE_CASE_		,     class_labels=SCREAMING_SNAKE_CASE_		,     )
  
           # 3. Output
           if self.is_input_continuous:
                if not self.use_linear_projection:
                     lowercase__					:     Tuple   = hidden_states.reshape(SCREAMING_SNAKE_CASE_		,     SCREAMING_SNAKE_CASE_		,     SCREAMING_SNAKE_CASE_		,     SCREAMING_SNAKE_CASE_).permute(0		,     3		,     1		,     2).contiguous()
                     lowercase__					:     int   = self.proj_out(SCREAMING_SNAKE_CASE_)
                else:
                     lowercase__					:     Optional[int]   = self.proj_out(SCREAMING_SNAKE_CASE_)
                     lowercase__					:     Optional[int]   = hidden_states.reshape(SCREAMING_SNAKE_CASE_		,     SCREAMING_SNAKE_CASE_		,     SCREAMING_SNAKE_CASE_		,     SCREAMING_SNAKE_CASE_).permute(0		,     3		,     1		,     2).contiguous()
  
                lowercase__					:     Any   = hidden_states + residual
           elif self.is_input_vectorized:
                lowercase__					:     List[Any]   = self.norm_out(SCREAMING_SNAKE_CASE_)
                lowercase__					:     Optional[int]   = self.out(SCREAMING_SNAKE_CASE_)
                # (batch, self.num_vector_embeds - 1, self.num_latent_pixels)
                lowercase__					:     Tuple   = logits.permute(0		,     2		,     1)
  
                # log(p(x_0))
                lowercase__					:     List[str]   = F.log_softmax(logits.double()		,     dim=1).float()
           elif self.is_input_patches:
                # TODO: cleanup!
                lowercase__					:     int   = self.transformer_blocks[0].norma.emb(
                    SCREAMING_SNAKE_CASE_		,     SCREAMING_SNAKE_CASE_		,     hidden_dtype=hidden_states.dtype)
                lowercase__					:     int   = self.proj_out_a(F.silu(SCREAMING_SNAKE_CASE_)).chunk(2		,     dim=1)
                lowercase__					:     Dict   = self.norm_out(SCREAMING_SNAKE_CASE_) * (1 + scale[:, None]) + shift[:, None]
                lowercase__					:     Any   = self.proj_out_a(SCREAMING_SNAKE_CASE_)
  
                # unpatchify
                lowercase__					:     Union[str, Any]   = int(hidden_states.shape[1] ** 0.5)
                lowercase__					:     Tuple   = hidden_states.reshape(
                    shape=(-1, height, width, self.patch_size, self.patch_size, self.out_channels))
                lowercase__					:     int   = torch.einsum('nhwpqc->nchpwq'		,     SCREAMING_SNAKE_CASE_)
                lowercase__					:     Any   = 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=SCREAMING_SNAKE_CASE_)
  
  
style_context: 
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available
  
  
  snake_case_    						=				{
      '''configuration_donut_swin''': ['''DONUT_SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''DonutSwinConfig'''],
      '''processing_donut''': ['''DonutProcessor'''],
  }
  
  try:
         if not is_torch_available():
                raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
         pass
  else:
         snake_case_    						=				[
             '''DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST''',
             '''DonutSwinModel''',
             '''DonutSwinPreTrainedModel''',
         ]
  
  try:
         if not is_vision_available():
                raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
         pass
  else:
         snake_case_    						=				['''DonutFeatureExtractor''']
         snake_case_    						=				['''DonutImageProcessor''']
  
  
  if TYPE_CHECKING:
         from .configuration_donut_swin import DONUT_SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP, DonutSwinConfig
         from .processing_donut import DonutProcessor
  
         try:
                if not is_torch_available():
                       raise OptionalDependencyNotAvailable()
         except OptionalDependencyNotAvailable:
                pass
         else:
                from .modeling_donut_swin import (
                    DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
                    DonutSwinModel,
                    DonutSwinPreTrainedModel,
                )
  
         try:
                if not is_vision_available():
                       raise OptionalDependencyNotAvailable()
         except OptionalDependencyNotAvailable:
                pass
         else:
                from .feature_extraction_donut import DonutFeatureExtractor
                from .image_processing_donut import DonutImageProcessor
  
  else:
         import sys
  
         snake_case_    						=				_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
  
  