

'''simple docstring'''






import unittest
from typing import Tuple

import torch

from diffusers.utils import floats_tensor, randn_tensor, torch_all_close, torch_device
from diffusers.utils.testing_utils import require_torch






@require_torch
class 			lowercase_	:




  """simple docstring"""




  @property
  def 					SCREAMING_SNAKE_CASE      (      self   :     List[Any]			):
   return self.get_dummy_input()






  @property
  def 					SCREAMING_SNAKE_CASE      (      self   :     Union[str, Any]			):
   if self.block_type == "down":
    return (4, 3_2, 1_6, 1_6)
   elif self.block_type == "mid":
    return (4, 3_2, 3_2, 3_2)
   elif self.block_type == "up":
    return (4, 3_2, 6_4, 6_4)

   raise ValueError(F"'{self.block_type}' is not a supported block_type. Set it to 'up', 'mid', or 'down'."			)






  def 					SCREAMING_SNAKE_CASE      (      self   :     Optional[int]					,lowercase__   :     int=True					,lowercase__   :     Dict=False					,lowercase__   :     Union[str, Any]=False					,lowercase__   :     Tuple=False					,):
   __lowercase							  = 4
   __lowercase							  = 3_2
   __lowercase							  = (3_2, 3_2)

   __lowercase							  = torch.manual_seed(0			)
   __lowercase							  = torch.device(lowercase__			)
   __lowercase							  = (batch_size, num_channels) + sizes
   __lowercase							  = randn_tensor(lowercase__					,generator=lowercase__					,device=lowercase__			)
   __lowercase							  = {'''hidden_states''': hidden_states}

   if include_temb:
    __lowercase							  = 1_2_8
    __lowercase							  = randn_tensor((batch_size, temb_channels)					,generator=lowercase__					,device=lowercase__			)

   if include_res_hidden_states_tuple:
    __lowercase							  = torch.manual_seed(1			)
    __lowercase							  = (randn_tensor(lowercase__					,generator=lowercase__					,device=lowercase__			),)

   if include_encoder_hidden_states:
    __lowercase							  = floats_tensor((batch_size, 3_2, 3_2)			).to(lowercase__			)

   if include_skip_sample:
    __lowercase							  = randn_tensor(((batch_size, 3) + sizes)					,generator=lowercase__					,device=lowercase__			)

   return dummy_input






  def 					SCREAMING_SNAKE_CASE      (      self   :     Any			):
   __lowercase							  = {
       '''in_channels''': 3_2,
       '''out_channels''': 3_2,
       '''temb_channels''': 1_2_8,
   }
   if self.block_type == "up":
    __lowercase							  = 3_2

   if self.block_type == "mid":
    init_dict.pop('''out_channels'''			)

   __lowercase							  = self.dummy_input
   return init_dict, inputs_dict






  def 					SCREAMING_SNAKE_CASE      (      self   :     Tuple					,lowercase__   :     Tuple			):
   __lowercase  ,	__lowercase							  = self.prepare_init_args_and_inputs_for_common()
   __lowercase							  = self.block_class(**lowercase__			)
   unet_block.to(lowercase__			)
   unet_block.eval()

   with torch.no_grad():
    __lowercase							  = unet_block(**lowercase__			)

   if isinstance(lowercase__					,lowercase__			):
    __lowercase							  = output[0]

   self.assertEqual(output.shape					,self.output_shape			)

   __lowercase							  = output[0, -1, -3:, -3:]
   __lowercase							  = torch.tensor(lowercase__			).to(lowercase__			)
   assert torch_all_close(output_slice.flatten()					,lowercase__					,atol=5e-3			)






  @unittest.skipIf(torch_device == '''mps'''					,'''Training is not supported in mps'''			)
  def 					SCREAMING_SNAKE_CASE      (      self   :     Dict			):
   __lowercase  ,	__lowercase							  = self.prepare_init_args_and_inputs_for_common()
   __lowercase							  = self.block_class(**lowercase__			)
   model.to(lowercase__			)
   model.train()
   __lowercase							  = model(**lowercase__			)

   if isinstance(lowercase__					,lowercase__			):
    __lowercase							  = output[0]

   __lowercase							  = torch.device(lowercase__			)
   __lowercase							  = randn_tensor(output.shape					,device=lowercase__			)
   __lowercase							  = torch.nn.functional.mse_loss(lowercase__					,lowercase__			)
   loss.backward()








import warnings
from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


__lowerCamelCase       :     Union[str, Any]   =     logging.get_logger(__name__)

__lowerCamelCase       :     Any   =     {
    """facebook/bart-large""": """https://huggingface.co/facebook/bart-large/resolve/main/config.json""",
    # See all BART models at https://huggingface.co/models?filter=bart
}



class 					A__   (       __snake_case			):
      _UpperCAmelCase	:Dict						    =   'bart'
      _UpperCAmelCase	:str						    =   ['past_key_values']
      _UpperCAmelCase	:Any						    =   {'num_attention_heads': 'encoder_attention_heads', 'hidden_size': 'd_model'}





      def __init__( self       ,							A_=5_0265       ,							A_=1024       ,							A_=12       ,							A_=4096       ,							A_=16       ,							A_=12       ,							A_=4096       ,							A_=16       ,							A_=0.0       ,							A_=0.0       ,							A_="gelu"       ,							A_=1024       ,							A_=0.1       ,							A_=0.0       ,							A_=0.0       ,							A_=0.02       ,							A_=0.0       ,							A_=False       ,							A_=True       ,							A_=3       ,							A_=1       ,							A_=0       ,							A_=2       ,							A_=True       ,							A_=2       ,							A_=2       ,							**A_       ,							):
       '''simple docstring'''




       UpperCamelCase	:					int       	=   vocab_size
       UpperCamelCase	:					List[Any]       	=   max_position_embeddings
       UpperCamelCase	:					Any       	=   d_model
       UpperCamelCase	:					Optional[Any]       	=   encoder_ffn_dim
       UpperCamelCase	:					List[Any]       	=   encoder_layers
       UpperCamelCase	:					int       	=   encoder_attention_heads
       UpperCamelCase	:					Optional[int]       	=   decoder_ffn_dim
       UpperCamelCase	:					List[str]       	=   decoder_layers
       UpperCamelCase	:					Optional[int]       	=   decoder_attention_heads
       UpperCamelCase	:					int       	=   dropout
       UpperCamelCase	:					int       	=   attention_dropout
       UpperCamelCase	:					Tuple       	=   activation_dropout
       UpperCamelCase	:					Tuple       	=   activation_function
       UpperCamelCase	:					int       	=   init_std
       UpperCamelCase	:					List[Any]       	=   encoder_layerdrop
       UpperCamelCase	:					List[str]       	=   decoder_layerdrop
       UpperCamelCase	:					Dict       	=   classifier_dropout
       UpperCamelCase	:					Optional[int]       	=   use_cache
       UpperCamelCase	:					List[Any]       	=   encoder_layers
       UpperCamelCase	:					int       	=   scale_embedding  # scale factor will be sqrt(d_model) if True

       super().__init__(
           num_labels=A_       ,							pad_token_id=A_       ,							bos_token_id=A_       ,							eos_token_id=A_       ,							is_encoder_decoder=A_       ,							decoder_start_token_id=A_       ,							forced_eos_token_id=A_       ,							**A_       ,							)

       # ensure backward compatibility for BART CNN models
       if self.forced_bos_token_id is None and kwargs.get("force_bos_token_to_be_generated"       ,							A_   ):
        UpperCamelCase	:					int       	=   self.bos_token_id
        warnings.warn(
            F"""Please make sure the config includes `forced_bos_token_id={self.bos_token_id}` in future versions. """
            "The config can simply be saved and uploaded again to be fixed."   )



class 					A__   (       __snake_case			):





      @property
      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       if self.task in ["default", "seq2seq-lm"]:
        UpperCamelCase	:					Optional[int]       	=   OrderedDict(
            [
                ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
            ]   )

        if self.use_past:
         UpperCamelCase	:					List[str]       	=   {0: "batch"}
         UpperCamelCase	:					Dict       	=   {0: "batch", 1: "past_decoder_sequence + sequence"}
        else:
         UpperCamelCase	:					Dict       	=   {0: "batch", 1: "decoder_sequence"}
         UpperCamelCase	:					Union[str, Any]       	=   {0: "batch", 1: "decoder_sequence"}

        if self.use_past:
         self.fill_with_past_key_values_(A_       ,							direction="inputs"   )
       elif self.task == "causal-lm":
        # TODO: figure this case out.
        UpperCamelCase	:					Any       	=   OrderedDict(
            [
                ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
            ]   )
        if self.use_past:
         UpperCamelCase	,    UpperCamelCase	:					Optional[int]       	=   self.num_layers
         for i in range(A_   ):
          UpperCamelCase	:					Optional[Any]       	=   {0: "batch", 2: "past_sequence + sequence"}
          UpperCamelCase	:					Union[str, Any]       	=   {0: "batch", 2: "past_sequence + sequence"}
       else:
        UpperCamelCase	:					Optional[Any]       	=   OrderedDict(
            [
                ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
                ("decoder_input_ids", {0: "batch", 1: "decoder_sequence"}),
                ("decoder_attention_mask", {0: "batch", 1: "decoder_sequence"}),
            ]   )

       return common_inputs





      @property
      def        __UpperCamelCase( self   ):
       '''simple docstring'''




       if self.task in ["default", "seq2seq-lm"]:
        UpperCamelCase	:					Tuple       	=   super().outputs
       else:
        UpperCamelCase	:					Dict       	=   super(A_       ,							self   ).outputs
        if self.use_past:
         UpperCamelCase	,    UpperCamelCase	:					int       	=   self.num_layers
         for i in range(A_   ):
          UpperCamelCase	:					int       	=   {0: "batch", 2: "past_sequence + sequence"}
          UpperCamelCase	:					Tuple       	=   {0: "batch", 2: "past_sequence + sequence"}
       return common_outputs





      def        __UpperCamelCase( self       ,							A_       ,							A_ = -1       ,							A_ = -1       ,							A_ = False       ,							A_ = None       ,							):
       '''simple docstring'''




       UpperCamelCase	:					List[Any]       	=   self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
           A_       ,							A_       ,							A_       ,							A_       ,							A_   )

       # Generate decoder inputs
       UpperCamelCase	:					List[Any]       	=   seq_length if not self.use_past else 1
       UpperCamelCase	:					Tuple       	=   self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
           A_       ,							A_       ,							A_       ,							A_       ,							A_   )
       UpperCamelCase	:					Optional[int]       	=   {F"""decoder_{name}""": tensor for name, tensor in decoder_inputs.items()}
       UpperCamelCase	:					List[Any]       	=   dict(**A_       ,							**A_   )

       if self.use_past:
        if not is_torch_available():
         raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed."   )
        else:
         import torch
        UpperCamelCase	,    UpperCamelCase	:					Optional[Any]       	=   common_inputs["input_ids"].shape
        UpperCamelCase	:					List[Any]       	=   common_inputs["decoder_input_ids"].shape[1]
        UpperCamelCase	,    UpperCamelCase	:					List[str]       	=   self.num_attention_heads
        UpperCamelCase	:					int       	=   (
            batch,
            num_encoder_attention_heads,
            encoder_seq_length,
            self._config.hidden_size // num_encoder_attention_heads,
        )
        UpperCamelCase	:					List[Any]       	=   decoder_seq_length + 3
        UpperCamelCase	:					str       	=   (
            batch,
            num_decoder_attention_heads,
            decoder_past_length,
            self._config.hidden_size // num_decoder_attention_heads,
        )

        UpperCamelCase	:					int       	=   torch.cat(
            [common_inputs["decoder_attention_mask"], torch.ones(A_       ,							A_   )]       ,							dim=1   )

        UpperCamelCase	:					int       	=   []
        # If the number of encoder and decoder layers are present in the model configuration, both are considered
        UpperCamelCase	,    UpperCamelCase	:					Union[str, Any]       	=   self.num_layers
        UpperCamelCase	:					Any       	=   min(A_       ,							A_   )
        UpperCamelCase	:					List[str]       	=   max(A_       ,							A_   ) - min_num_layers
        UpperCamelCase	:					Dict       	=   "encoder" if num_encoder_layers > num_decoder_layers else "decoder"

        for _ in range(A_   ):
         common_inputs["past_key_values"].append(
             (
                 torch.zeros(A_   ),
                 torch.zeros(A_   ),
                 torch.zeros(A_   ),
                 torch.zeros(A_   ),
             )   )
        # TODO: test this.
        UpperCamelCase	:					Optional[Any]       	=   encoder_shape if remaining_side_name == "encoder" else decoder_shape
        for _ in range(A_       ,							A_   ):
         common_inputs["past_key_values"].append((torch.zeros(A_   ), torch.zeros(A_   ))   )
       return common_inputs





      def        __UpperCamelCase( self       ,							A_       ,							A_ = -1       ,							A_ = -1       ,							A_ = False       ,							A_ = None       ,							):
       '''simple docstring'''




       UpperCamelCase	:					int       	=   self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
           A_       ,							A_       ,							A_       ,							A_       ,							A_   )

       if self.use_past:
        if not is_torch_available():
         raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed."   )
        else:
         import torch
        UpperCamelCase	,    UpperCamelCase	:					Union[str, Any]       	=   common_inputs["input_ids"].shape
        # Not using the same length for past_key_values
        UpperCamelCase	:					Optional[Any]       	=   seqlen + 2
        UpperCamelCase	,    UpperCamelCase	:					List[Any]       	=   self.num_layers
        UpperCamelCase	,    UpperCamelCase	:					Optional[int]       	=   self.num_attention_heads
        UpperCamelCase	:					str       	=   (
            batch,
            num_encoder_attention_heads,
            past_key_values_length,
            self._config.hidden_size // num_encoder_attention_heads,
        )

        UpperCamelCase	:					Optional[Any]       	=   common_inputs["attention_mask"].dtype
        UpperCamelCase	:					int       	=   torch.cat(
            [common_inputs["attention_mask"], torch.ones(A_       ,							A_       ,							dtype=A_   )]       ,							dim=1   )
        UpperCamelCase	:					Optional[Any]       	=   [
            (torch.zeros(A_   ), torch.zeros(A_   )) for _ in range(A_   )
        ]
       return common_inputs





      def        __UpperCamelCase( self       ,							A_       ,							A_ = -1       ,							A_ = -1       ,							A_ = False       ,							A_ = None       ,							):
       '''simple docstring'''




       UpperCamelCase	:					Optional[Any]       	=   compute_effective_axis_dimension(
           A_       ,							fixed_dimension=OnnxConfig.default_fixed_batch       ,							num_token_to_add=0   )

       # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
       UpperCamelCase	:					Union[str, Any]       	=   tokenizer.num_special_tokens_to_add(A_   )
       UpperCamelCase	:					int       	=   compute_effective_axis_dimension(
           A_       ,							fixed_dimension=OnnxConfig.default_fixed_sequence       ,							num_token_to_add=A_   )

       # Generate dummy inputs according to compute batch and sequence
       UpperCamelCase	:					int       	=   [" ".join([tokenizer.unk_token]   ) * seq_length] * batch_size
       UpperCamelCase	:					Dict       	=   dict(tokenizer(A_       ,							return_tensors=A_   )   )
       return common_inputs





      def        __UpperCamelCase( self       ,							A_       ,							A_ = -1       ,							A_ = -1       ,							A_ = False       ,							A_ = None       ,							):
       '''simple docstring'''




       if self.task in ["default", "seq2seq-lm"]:
        UpperCamelCase	:					Optional[int]       	=   self._generate_dummy_inputs_for_default_and_seqaseq_lm(
            A_       ,							batch_size=A_       ,							seq_length=A_       ,							is_pair=A_       ,							framework=A_   )

       elif self.task == "causal-lm":
        UpperCamelCase	:					List[str]       	=   self._generate_dummy_inputs_for_causal_lm(
            A_       ,							batch_size=A_       ,							seq_length=A_       ,							is_pair=A_       ,							framework=A_   )
       else:
        UpperCamelCase	:					List[str]       	=   self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
            A_       ,							batch_size=A_       ,							seq_length=A_       ,							is_pair=A_       ,							framework=A_   )

       return common_inputs





      def        __UpperCamelCase( self       ,							A_       ,							A_       ,							A_       ,							A_   ):
       '''simple docstring'''




       if self.task in ["default", "seq2seq-lm"]:
        UpperCamelCase	:					Optional[Any]       	=   super()._flatten_past_key_values_(A_       ,							A_       ,							A_       ,							A_   )
       else:
        UpperCamelCase	:					Optional[Any]       	=   super(A_       ,							self   )._flatten_past_key_values_(
            A_       ,							A_       ,							A_       ,							A_   )
