

"""simple docstring"""

import gc
import random
import unittest

import numpy as np
import torch
from transformers import XLMRobertaTokenizerFast

from diffusers import DDIMScheduler, KandinskyPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()


class       _snake_case  (    lowercase__    ,      unittest.TestCase							):
						__snake_case			      =  KandinskyPipeline
						__snake_case			      =  [
						    'prompt',
						    'image_embeds',
						    'negative_image_embeds',
						]
						__snake_case			      =  ['prompt', 'negative_prompt', 'image_embeds', 'negative_image_embeds']
						__snake_case			      =  [
						    'generator',
						    'height',
						    'width',
						    'latents',
						    'guidance_scale',
						    'negative_prompt',
						    'num_inference_steps',
						    'return_dict',
						    'guidance_scale',
						    'num_images_per_prompt',
						    'output_type',
						    'return_dict',
						]
						__snake_case			      =  False







						@property
						def 							_UpperCamelCase     (self				)      ->    List[Any]:
											return 3_2







						@property
						def 							_UpperCamelCase     (self				)      ->    Any:
											return 3_2







						@property
						def 							_UpperCamelCase     (self				)      ->    Any:
											return self.time_input_dim







						@property
						def 							_UpperCamelCase     (self				)      ->    Any:
											return self.time_input_dim * 4







						@property
						def 							_UpperCamelCase     (self				)      ->    Tuple:
											return 1_0_0







						@property
						def 							_UpperCamelCase     (self				)      ->    List[str]:
											__lowercase        =      XLMRobertaTokenizerFast.from_pretrained('''YiYiXu/tiny-random-mclip-base'''				)
											return tokenizer







						@property
						def 							_UpperCamelCase     (self				)      ->    Any:
											torch.manual_seed(0				)
											__lowercase        =      MCLIPConfig(
											    numDims=self.cross_attention_dim  ,				transformerDimensions=self.text_embedder_hidden_size  ,				hidden_size=self.text_embedder_hidden_size  ,				intermediate_size=3_7  ,				num_attention_heads=4  ,				num_hidden_layers=5  ,				vocab_size=1_0_0_5  ,				)

											__lowercase        =      MultilingualCLIP(SCREAMING_SNAKE_CASE__				)
											__lowercase        =      text_encoder.eval()

											return text_encoder







						@property
						def 							_UpperCamelCase     (self				)      ->    Optional[Any]:
											torch.manual_seed(0				)

											__lowercase        =      {
											    """in_channels""": 4,
											    # Out channels is double in channels because predicts mean and variance
											    """out_channels""": 8,
											    """addition_embed_type""": """text_image""",
											    """down_block_types""": ("""ResnetDownsampleBlock2D""", """SimpleCrossAttnDownBlock2D"""),
											    """up_block_types""": ("""SimpleCrossAttnUpBlock2D""", """ResnetUpsampleBlock2D"""),
											    """mid_block_type""": """UNetMidBlock2DSimpleCrossAttn""",
											    """block_out_channels""": (self.block_out_channels_a, self.block_out_channels_a * 2),
											    """layers_per_block""": 1,
											    """encoder_hid_dim""": self.text_embedder_hidden_size,
											    """encoder_hid_dim_type""": """text_image_proj""",
											    """cross_attention_dim""": self.cross_attention_dim,
											    """attention_head_dim""": 4,
											    """resnet_time_scale_shift""": """scale_shift""",
											    """class_embed_type""": None,
											}

											__lowercase        =      UNetaDConditionModel(**SCREAMING_SNAKE_CASE__				)
											return model







						@property
						def 							_UpperCamelCase     (self				)      ->    List[Any]:
											return {
											    "block_out_channels": [3_2, 6_4],
											    "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
											    "in_channels": 3,
											    "latent_channels": 4,
											    "layers_per_block": 1,
											    "norm_num_groups": 8,
											    "norm_type": "spatial",
											    "num_vq_embeddings": 1_2,
											    "out_channels": 3,
											    "up_block_types": [
											        "AttnUpDecoderBlock2D",
											        "UpDecoderBlock2D",
											    ],
											    "vq_embed_dim": 4,
											}







						@property
						def 							_UpperCamelCase     (self				)      ->    Optional[Any]:
											torch.manual_seed(0				)
											__lowercase        =      VQModel(**self.dummy_movq_kwargs				)
											return model







						def 							_UpperCamelCase     (self				)      ->    List[Any]:
											__lowercase        =      self.dummy_text_encoder
											__lowercase        =      self.dummy_tokenizer
											__lowercase        =      self.dummy_unet
											__lowercase        =      self.dummy_movq

											__lowercase        =      DDIMScheduler(
											    num_train_timesteps=1_0_0_0  ,				beta_schedule='''linear'''  ,				beta_start=0.0_0_0_8_5  ,				beta_end=0.0_1_2  ,				clip_sample=SCREAMING_SNAKE_CASE__  ,				set_alpha_to_one=SCREAMING_SNAKE_CASE__  ,				steps_offset=1  ,				prediction_type='''epsilon'''  ,				thresholding=SCREAMING_SNAKE_CASE__  ,				)

											__lowercase        =      {
											    """text_encoder""": text_encoder,
											    """tokenizer""": tokenizer,
											    """unet""": unet,
											    """scheduler""": scheduler,
											    """movq""": movq,
											}
											return components







						def 							_UpperCamelCase     (self  ,				UpperCAmelCase_  ,				UpperCAmelCase_=0				)      ->    Optional[int]:
											__lowercase        =      floats_tensor((1, self.cross_attention_dim)  ,				rng=random.Random(SCREAMING_SNAKE_CASE__				)				).to(SCREAMING_SNAKE_CASE__				)
											__lowercase        =      floats_tensor((1, self.cross_attention_dim)  ,				rng=random.Random(seed + 1				)				).to(SCREAMING_SNAKE_CASE__				)
											if str(SCREAMING_SNAKE_CASE__				).startswith('''mps'''				):
																__lowercase        =      torch.manual_seed(SCREAMING_SNAKE_CASE__				)
											else:
																__lowercase        =      torch.Generator(device=SCREAMING_SNAKE_CASE__				).manual_seed(SCREAMING_SNAKE_CASE__				)
											__lowercase        =      {
											    """prompt""": """horse""",
											    """image_embeds""": image_embeds,
											    """negative_image_embeds""": negative_image_embeds,
											    """generator""": generator,
											    """height""": 6_4,
											    """width""": 6_4,
											    """guidance_scale""": 4.0,
											    """num_inference_steps""": 2,
											    """output_type""": """np""",
											}
											return inputs







						def 							_UpperCamelCase     (self				)      ->    Tuple:
											__lowercase        =      """cpu"""

											__lowercase        =      self.get_dummy_components()

											__lowercase        =      self.pipeline_class(**SCREAMING_SNAKE_CASE__				)
											__lowercase        =      pipe.to(SCREAMING_SNAKE_CASE__				)

											pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__				)

											__lowercase        =      pipe(**self.get_dummy_inputs(SCREAMING_SNAKE_CASE__				)				)
											__lowercase        =      output.images

											__lowercase        =      pipe(
											    **self.get_dummy_inputs(SCREAMING_SNAKE_CASE__				)  ,				return_dict=SCREAMING_SNAKE_CASE__  ,				)[0]

											__lowercase        =      image[0, -3:, -3:, -1]
											__lowercase        =      image_from_tuple[0, -3:, -3:, -1]

											assert image.shape == (1, 6_4, 6_4, 3)

											__lowercase        =      np.array(
											    [0.3_2_8_6_6_3, 1.0, 0.2_3_2_1_6_8_7_3, 1.0, 0.9_2_7_1_7_5_6_4, 0.4_6_3_9_0_4_6, 0.9_6_8_9_4_7_7_7, 0.3_1_7_1_3_3_7_8, 0.6_2_9_3_9_5_3]				)

											assert (
											    np.abs(image_slice.flatten() - expected_slice				).max() < 1e-2
											), f''' expected_slice {expected_slice}, but got {image_slice.flatten()}'''
											assert (
											    np.abs(image_from_tuple_slice.flatten() - expected_slice				).max() < 1e-2
											), f''' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}'''



@slow
@require_torch_gpu
class       _snake_case  (    unittest.TestCase							):







						def 							_UpperCamelCase     (self				)      ->    Tuple:
											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()







						def 							_UpperCamelCase     (self				)      ->    int:
											__lowercase        =      load_numpy(
											    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
											    '''/kandinsky/kandinsky_text2img_cat_fp16.npy'''				)

											__lowercase        =      KandinskyPriorPipeline.from_pretrained(
											    '''kandinsky-community/kandinsky-2-1-prior'''  ,				torch_dtype=torch.floataa				)
											pipe_prior.to(SCREAMING_SNAKE_CASE__				)

											__lowercase        =      KandinskyPipeline.from_pretrained('''kandinsky-community/kandinsky-2-1'''  ,				torch_dtype=torch.floataa				)
											__lowercase        =      pipeline.to(SCREAMING_SNAKE_CASE__				)
											pipeline.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__				)

											__lowercase        =      """red cat, 4k photo"""

											__lowercase        =      torch.Generator(device='''cuda'''				).manual_seed(0				)
											__lowercase        =      pipe_prior(
											    SCREAMING_SNAKE_CASE__  ,				generator=SCREAMING_SNAKE_CASE__  ,				num_inference_steps=5  ,				negative_prompt=''''''  ,				).to_tuple()

											__lowercase        =      torch.Generator(device='''cuda'''				).manual_seed(0				)
											__lowercase        =      pipeline(
											    SCREAMING_SNAKE_CASE__  ,				image_embeds=SCREAMING_SNAKE_CASE__  ,				negative_image_embeds=SCREAMING_SNAKE_CASE__  ,				generator=SCREAMING_SNAKE_CASE__  ,				num_inference_steps=1_0_0  ,				output_type='''np'''  ,				)

											__lowercase        =      output.images[0]

											assert image.shape == (5_1_2, 5_1_2, 3)

											assert_mean_pixel_difference(SCREAMING_SNAKE_CASE__  ,				SCREAMING_SNAKE_CASE__				)







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


UpperCAmelCase_			      =  logging.get_logger(__name__)

UpperCAmelCase_			      =  {
    '''google/bigbird-pegasus-large-arxiv''': (
        '''https://huggingface.co/google/bigbird-pegasus-large-arxiv/resolve/main/config.json'''
    ),
    '''google/bigbird-pegasus-large-pubmed''': (
        '''https://huggingface.co/google/bigbird-pegasus-large-pubmed/resolve/main/config.json'''
    ),
    '''google/bigbird-pegasus-large-bigpatent''': (
        '''https://huggingface.co/google/bigbird-pegasus-large-bigpatent/resolve/main/config.json'''
    ),
    # See all BigBirdPegasus models at https://huggingface.co/models?filter=bigbird_pegasus
}





class 		__SCREAMING_SNAKE_CASE      (				lowercase__      ):






				"""simple docstring"""

				SCREAMING_SNAKE_CASE_ 				=  'bigbird_pegasus'
				SCREAMING_SNAKE_CASE_ 				=  ['past_key_values']
				SCREAMING_SNAKE_CASE_ 				=  {
				    'num_attention_heads': 'encoder_attention_heads',
				    'hidden_size': 'd_model',
				    'attention_probs_dropout_prob': 'attention_dropout',
				}







				def __init__(				self						,	SCREAMING_SNAKE_CASE__=9_61_03						,	SCREAMING_SNAKE_CASE__=40_96						,	SCREAMING_SNAKE_CASE__=16						,	SCREAMING_SNAKE_CASE__=40_96						,	SCREAMING_SNAKE_CASE__=16						,	SCREAMING_SNAKE_CASE__=16						,	SCREAMING_SNAKE_CASE__=40_96						,	SCREAMING_SNAKE_CASE__=16						,	SCREAMING_SNAKE_CASE__=0.0						,	SCREAMING_SNAKE_CASE__=0.0						,	SCREAMING_SNAKE_CASE__=True						,	SCREAMING_SNAKE_CASE__=True						,	SCREAMING_SNAKE_CASE__="gelu_new"						,	SCREAMING_SNAKE_CASE__=10_24						,	SCREAMING_SNAKE_CASE__=0.1						,	SCREAMING_SNAKE_CASE__=0.0						,	SCREAMING_SNAKE_CASE__=0.0						,	SCREAMING_SNAKE_CASE__=0.02						,	SCREAMING_SNAKE_CASE__=2						,	SCREAMING_SNAKE_CASE__=0.0						,	SCREAMING_SNAKE_CASE__=True						,	SCREAMING_SNAKE_CASE__=0						,	SCREAMING_SNAKE_CASE__=2						,	SCREAMING_SNAKE_CASE__=1						,	SCREAMING_SNAKE_CASE__="block_sparse"						,	SCREAMING_SNAKE_CASE__=64						,	SCREAMING_SNAKE_CASE__=3						,	SCREAMING_SNAKE_CASE__=False						,	**SCREAMING_SNAKE_CASE__						,	):






					"""simple docstring"""

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

					# extra config
					_snake_case					:							str					     =   attention_type
					_snake_case					:							Tuple					     =   block_size
					_snake_case					:							List[Any]					     =   num_random_blocks
					_snake_case					:							List[str]					     =   use_bias

					super().__init__(
					    pad_token_id=SCREAMING_SNAKE_CASE__						,	bos_token_id=SCREAMING_SNAKE_CASE__						,	eos_token_id=SCREAMING_SNAKE_CASE__						,	is_encoder_decoder=SCREAMING_SNAKE_CASE__						,	decoder_start_token_id=SCREAMING_SNAKE_CASE__						,	**SCREAMING_SNAKE_CASE__						,	)





class 		__SCREAMING_SNAKE_CASE      (				lowercase__      ):






				"""simple docstring"""

				@property
				def 		__lowerCamelCase(				self      ):






					"""simple docstring"""

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

						if self.use_past:
							_snake_case					:							Any					     =   {0: """batch"""}
							_snake_case					:							str					     =   {0: """batch""", 1: """past_decoder_sequence + sequence"""}
						else:
							_snake_case					:							int					     =   {0: """batch""", 1: """decoder_sequence"""}
							_snake_case					:							Optional[Any]					     =   {0: """batch""", 1: """decoder_sequence"""}

						if self.use_past:
							self.fill_with_past_key_values_(SCREAMING_SNAKE_CASE__						,	direction="""inputs"""      )
					elif self.task == "causal-lm":
						# TODO: figure this case out.
						_snake_case					:							Any					     =   OrderedDict(
						    [
						        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
						        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
						    ]      )
						if self.use_past:
							_snake_case     , _snake_case					:							Tuple					     =   self.num_layers
							for i in range(SCREAMING_SNAKE_CASE__      ):
								_snake_case					:							Dict					     =   {0: """batch""", 2: """past_sequence + sequence"""}
								_snake_case					:							int					     =   {0: """batch""", 2: """past_sequence + sequence"""}
					else:
						_snake_case					:							Dict					     =   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 		__lowerCamelCase(				self      ):






					"""simple docstring"""

					if self.task in ["default", "seq2seq-lm"]:
						_snake_case					:							str					     =   super().outputs
					else:
						_snake_case					:							List[Any]					     =   super(SCREAMING_SNAKE_CASE__						,	self      ).outputs
						if self.use_past:
							_snake_case     , _snake_case					:							List[str]					     =   self.num_layers
							for i in range(SCREAMING_SNAKE_CASE__      ):
								_snake_case					:							Optional[Any]					     =   {0: """batch""", 2: """past_sequence + sequence"""}
								_snake_case					:							List[str]					     =   {0: """batch""", 2: """past_sequence + sequence"""}
					return common_outputs







				def 		__lowerCamelCase(				self						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__ = -1						,	SCREAMING_SNAKE_CASE__ = -1						,	SCREAMING_SNAKE_CASE__ = False						,	SCREAMING_SNAKE_CASE__ = None						,	):






					"""simple docstring"""

					_snake_case					:							Optional[Any]					     =   self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
					    SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__      )

					# Generate decoder inputs
					_snake_case					:							Union[str, Any]					     =   seq_length if not self.use_past else 1
					_snake_case					:							Tuple					     =   self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
					    SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__      )
					_snake_case					:							Union[str, Any]					     =   {f'''decoder_{name}''': tensor for name, tensor in decoder_inputs.items()}
					_snake_case					:							Optional[int]					     =   dict(**SCREAMING_SNAKE_CASE__						,	**SCREAMING_SNAKE_CASE__      )

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

						_snake_case					:							List[str]					     =   torch.cat(
						    [common_inputs["""decoder_attention_mask"""], torch.ones(SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__      )]						,	dim=1      )

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

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







				def 		__lowerCamelCase(				self						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__ = -1						,	SCREAMING_SNAKE_CASE__ = -1						,	SCREAMING_SNAKE_CASE__ = False						,	SCREAMING_SNAKE_CASE__ = None						,	):






					"""simple docstring"""

					_snake_case					:							Tuple					     =   self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
					    SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__      )

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

						_snake_case					:							Optional[int]					     =   common_inputs["""attention_mask"""].dtype
						_snake_case					:							str					     =   torch.cat(
						    [common_inputs["""attention_mask"""], torch.ones(SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	dtype=SCREAMING_SNAKE_CASE__      )]						,	dim=1      )
						_snake_case					:							Tuple					     =   [
						    (torch.zeros(SCREAMING_SNAKE_CASE__      ), torch.zeros(SCREAMING_SNAKE_CASE__      )) for _ in range(SCREAMING_SNAKE_CASE__      )
						]
					return common_inputs







				def 		__lowerCamelCase(				self						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__ = -1						,	SCREAMING_SNAKE_CASE__ = -1						,	SCREAMING_SNAKE_CASE__ = False						,	SCREAMING_SNAKE_CASE__ = None						,	):






					"""simple docstring"""

					_snake_case					:							Optional[int]					     =   compute_effective_axis_dimension(
					    SCREAMING_SNAKE_CASE__						,	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
					_snake_case					:							List[str]					     =   tokenizer.num_special_tokens_to_add(SCREAMING_SNAKE_CASE__      )
					_snake_case					:							Tuple					     =   compute_effective_axis_dimension(
					    SCREAMING_SNAKE_CASE__						,	fixed_dimension=OnnxConfig.default_fixed_sequence						,	num_token_to_add=SCREAMING_SNAKE_CASE__      )

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







				def 		__lowerCamelCase(				self						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__ = -1						,	SCREAMING_SNAKE_CASE__ = -1						,	SCREAMING_SNAKE_CASE__ = False						,	SCREAMING_SNAKE_CASE__ = None						,	):






					"""simple docstring"""

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

					elif self.task == "causal-lm":
						_snake_case					:							List[Any]					     =   self._generate_dummy_inputs_for_causal_lm(
						    SCREAMING_SNAKE_CASE__						,	batch_size=SCREAMING_SNAKE_CASE__						,	seq_length=SCREAMING_SNAKE_CASE__						,	is_pair=SCREAMING_SNAKE_CASE__						,	framework=SCREAMING_SNAKE_CASE__      )
					else:
						_snake_case					:							Dict					     =   self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
						    SCREAMING_SNAKE_CASE__						,	batch_size=SCREAMING_SNAKE_CASE__						,	seq_length=SCREAMING_SNAKE_CASE__						,	is_pair=SCREAMING_SNAKE_CASE__						,	framework=SCREAMING_SNAKE_CASE__      )

					return common_inputs







				def 		__lowerCamelCase(				self						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__      ):






					"""simple docstring"""

					if self.task in ["default", "seq2seq-lm"]:
						_snake_case					:							Union[str, Any]					     =   super()._flatten_past_key_values_(SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__      )
					else:
						_snake_case					:							int					     =   super(SCREAMING_SNAKE_CASE__						,	self      )._flatten_past_key_values_(
						    SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__      )





