


'''simple docstring'''






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

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

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput
from .attention import BasicTransformerBlock
from .attention_processor import AttentionProcessor, AttnProcessor
from .embeddings import TimestepEmbedding, Timesteps
from .modeling_utils import ModelMixin




@dataclass
class  a     (     _SCREAMING_SNAKE_CASE       ):
 _lowerCAmelCase 					=	42





class  a     (     _SCREAMING_SNAKE_CASE  ,				_SCREAMING_SNAKE_CASE       ):
 @register_to_config
 def __init__( self      ,				__magic_name__ = 32      ,				__magic_name__ = 64      ,				__magic_name__ = 20      ,				__magic_name__ = 7_68      ,				__magic_name__=77      ,				__magic_name__=4      ,				__magic_name__ = 0.0      ,				__magic_name__ = "silu"      ,				__magic_name__ = None      ,				__magic_name__ = None      ,				__magic_name__ = "linear"      ,				__magic_name__ = "prd"      ,				__magic_name__ = None      ,				__magic_name__ = None      ,				__magic_name__ = None      ,				)					->							int:
      super().__init__()
      _a			      =							num_attention_heads
      _a			      =							attention_head_dim
      _a			      =							num_attention_heads * attention_head_dim
      _a			      =							additional_embeddings

      _a			      =							time_embed_dim or inner_dim
      _a			      =							embedding_proj_dim or embedding_dim
      _a			      =							clip_embed_dim or embedding_dim

      _a			      =							Timesteps(__magic_name__      ,				__magic_name__      ,				0						)
      _a			      =							TimestepEmbedding(__magic_name__      ,				__magic_name__      ,				out_dim=__magic_name__      ,				act_fn=__magic_name__						)

      _a			      =							nn.Linear(__magic_name__      ,				__magic_name__						)

      if embedding_proj_norm_type is None:
           _a			      =							None
      elif embedding_proj_norm_type == "layer":
           _a			      =							nn.LayerNorm(__magic_name__						)
      else:
           raise ValueError(f'unsupported embedding_proj_norm_type: {embedding_proj_norm_type}'						)

      _a			      =							nn.Linear(__magic_name__      ,				__magic_name__						)

      if encoder_hid_proj_type is None:
           _a			      =							None
      elif encoder_hid_proj_type == "linear":
           _a			      =							nn.Linear(__magic_name__      ,				__magic_name__						)
      else:
           raise ValueError(f'unsupported encoder_hid_proj_type: {encoder_hid_proj_type}'						)

      _a			      =							nn.Parameter(torch.zeros(1      ,				num_embeddings + additional_embeddings      ,				__magic_name__						)						)

      if added_emb_type == "prd":
           _a			      =							nn.Parameter(torch.zeros(1      ,				1      ,				__magic_name__						)						)
      elif added_emb_type is None:
           _a			      =							None
      else:
           raise ValueError(
               f'`added_emb_type`: {added_emb_type} is not supported. Make sure to choose one of `\'prd\'` or `None`.'						)

      _a			      =							nn.ModuleList(
          [
              BasicTransformerBlock(
                  __magic_name__      ,				__magic_name__      ,				__magic_name__      ,				dropout=__magic_name__      ,				activation_fn='gelu'      ,				attention_bias=__magic_name__      ,				)
              for d in range(__magic_name__						)
          ]						)

      if norm_in_type == "layer":
           _a			      =							nn.LayerNorm(__magic_name__						)
      elif norm_in_type is None:
           _a			      =							None
      else:
           raise ValueError(f'Unsupported norm_in_type: {norm_in_type}.'						)

      _a			      =							nn.LayerNorm(__magic_name__						)

      _a			      =							nn.Linear(__magic_name__      ,				__magic_name__						)

      _a			      =							torch.full(
          [num_embeddings + additional_embeddings, num_embeddings + additional_embeddings]      ,				-1_0_0_0_0.0						)
      causal_attention_mask.triu_(1						)
      _a			      =							causal_attention_mask[None, ...]
      self.register_buffer('causal_attention_mask'      ,				__magic_name__      ,				persistent=__magic_name__						)

      _a			      =							nn.Parameter(torch.zeros(1      ,				__magic_name__						)						)
      _a			      =							nn.Parameter(torch.zeros(1      ,				__magic_name__						)						)
 @property
 # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.attn_processors
 def 							__UpperCAmelCase		( self						)					->							Dict[str, AttentionProcessor]:
      _a			      =							{}

      def fn_recursive_add_processors(__magic_name__      ,				__magic_name__      ,				__magic_name__						):
           if hasattr(__magic_name__      ,				'set_processor'						):
                _a			      =							module.processor

           for sub_name, child in module.named_children():
                fn_recursive_add_processors(f'{name}.{sub_name}'      ,				__magic_name__      ,				__magic_name__						)

           return processors

      for name, module in self.named_children():
           fn_recursive_add_processors(__magic_name__      ,				__magic_name__      ,				__magic_name__						)

      return processors
 def 							__UpperCAmelCase		( self      ,				__magic_name__						)					->							Any:
      _a			      =							len(self.attn_processors.keys()						)

      if isinstance(__magic_name__      ,				__magic_name__						) and len(__magic_name__						) != count:
           raise ValueError(
               f'A dict of processors was passed, but the number of processors {len(__magic_name__						)} does not match the'
               f' number of attention layers: {count}. Please make sure to pass {count} processor classes.'						)

      def fn_recursive_attn_processor(__magic_name__      ,				__magic_name__      ,				__magic_name__						):
           if hasattr(__magic_name__      ,				'set_processor'						):
                if not isinstance(__magic_name__      ,				__magic_name__						):
                     module.set_processor(__magic_name__						)
                else:
                     module.set_processor(processor.pop(f'{name}.processor'						)						)

           for sub_name, child in module.named_children():
                fn_recursive_attn_processor(f'{name}.{sub_name}'      ,				__magic_name__      ,				__magic_name__						)

      for name, module in self.named_children():
           fn_recursive_attn_processor(__magic_name__      ,				__magic_name__      ,				__magic_name__						)
 def 							__UpperCAmelCase		( self						)					->							Optional[Any]:
      self.set_attn_processor(AttnProcessor()						)
 def 							__UpperCAmelCase		( self      ,				__magic_name__      ,				__magic_name__      ,				__magic_name__      ,				__magic_name__ = None      ,				__magic_name__ = None      ,				__magic_name__ = True      ,				)					->							Any:
      _a			      =							hidden_states.shape[0]

      _a			      =							timestep
      if not torch.is_tensor(__magic_name__						):
           _a			      =							torch.tensor([timesteps]      ,				dtype=torch.long      ,				device=hidden_states.device						)
      elif torch.is_tensor(__magic_name__						) and len(timesteps.shape						) == 0:
           _a			      =							timesteps[None].to(hidden_states.device						)

      # broadcast to batch dimension in a way that's compatible with ONNX/Core ML
      _a			      =							timesteps * torch.ones(__magic_name__      ,				dtype=timesteps.dtype      ,				device=timesteps.device						)

      _a			      =							self.time_proj(__magic_name__						)

      # timesteps does not contain any weights and will always return f32 tensors
      # but time_embedding might be fp16, so we need to cast here.
      _a			      =							timesteps_projected.to(dtype=self.dtype						)
      _a			      =							self.time_embedding(__magic_name__						)

      if self.embedding_proj_norm is not None:
           _a			      =							self.embedding_proj_norm(__magic_name__						)

      _a			      =							self.embedding_proj(__magic_name__						)
      if self.encoder_hidden_states_proj is not None and encoder_hidden_states is not None:
           _a			      =							self.encoder_hidden_states_proj(__magic_name__						)
      elif self.encoder_hidden_states_proj is not None and encoder_hidden_states is None:
           raise ValueError('`encoder_hidden_states_proj` requires `encoder_hidden_states` to be set'						)

      _a			      =							self.proj_in(__magic_name__						)

      _a			      =							self.positional_embedding.to(hidden_states.dtype						)

      _a			      =							[]
      _a			      =							0

      if encoder_hidden_states is not None:
           additional_embeds.append(__magic_name__						)
           additional_embeddings_len += encoder_hidden_states.shape[1]

      if len(proj_embeddings.shape						) == 2:
           _a			      =							proj_embeddings[:, None, :]

      if len(hidden_states.shape						) == 2:
           _a			      =							hidden_states[:, None, :]

      _a			      =							additional_embeds + [
          proj_embeddings,
          time_embeddings[:, None, :],
          hidden_states,
      ]

      if self.prd_embedding is not None:
           _a			      =							self.prd_embedding.to(hidden_states.dtype						).expand(__magic_name__      ,				-1      ,				-1						)
           additional_embeds.append(__magic_name__						)

      _a			      =							torch.cat(
          __magic_name__      ,				dim=1      ,				)

      # Allow positional_embedding to not include the `addtional_embeddings` and instead pad it with zeros for these additional tokens
      _a			      =							additional_embeddings_len + proj_embeddings.shape[1] + 1
      if positional_embeddings.shape[1] < hidden_states.shape[1]:
           _a			      =							F.pad(
               __magic_name__      ,				(
                   0,
                   0,
                   additional_embeddings_len,
                   self.prd_embedding.shape[1] if self.prd_embedding is not None else 0,
               )      ,				value=0.0      ,				)

      _a			      =							hidden_states + positional_embeddings

      if attention_mask is not None:
           _a			      =							(1 - attention_mask.to(hidden_states.dtype						)) * -1_0_0_0_0.0
           _a			      =							F.pad(__magic_name__      ,				(0, self.additional_embeddings)      ,				value=0.0						)
           _a			      =							(attention_mask[:, None, :] + self.causal_attention_mask).to(hidden_states.dtype						)
           _a			      =							attention_mask.repeat_interleave(self.config.num_attention_heads      ,				dim=0						)

      if self.norm_in is not None:
           _a			      =							self.norm_in(__magic_name__						)

      for block in self.transformer_blocks:
           _a			      =							block(__magic_name__      ,				attention_mask=__magic_name__						)

      _a			      =							self.norm_out(__magic_name__						)

      if self.prd_embedding is not None:
           _a			      =							hidden_states[:, -1]
      else:
           _a			      =							hidden_states[:, additional_embeddings_len:]

      _a			      =							self.proj_to_clip_embeddings(__magic_name__						)

      if not return_dict:
           return (predicted_image_embedding,)

      return PriorTransformerOutput(predicted_image_embedding=__magic_name__						)




 def 							__UpperCAmelCase		( self      ,				__magic_name__						)					->							str:
      _a			      =							(prior_latents * self.clip_std) + self.clip_mean
      return prior_latents





'''simple docstring'''






import warnings

from ...utils import logging
from .image_processing_donut import DonutImageProcessor


a_					:    Optional[Any]          =    logging.get_logger(__name__)




class  a     (     _SCREAMING_SNAKE_CASE       ):
 def __init__( self      ,				*__magic_name__      ,				**__magic_name__						)					->							None:
      warnings.warn(
          'The class DonutFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please'
          ' use DonutImageProcessor instead.'      ,				__magic_name__      ,				)
      super().__init__(*__magic_name__      ,				**__magic_name__						)

