

'''simple docstring'''




import copy
import inspect
import unittest

from transformers import PretrainedConfig, SwiftFormerConfig
from transformers.testing_utils import (
    require_torch,
    require_vision,
    slow,
    torch_device,
)
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
						import torch
						from torch import nn

						from transformers import SwiftFormerForImageClassification, SwiftFormerModel
						from transformers.models.swiftformer.modeling_swiftformer import SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
						from PIL import Image

						from transformers import ViTImageProcessor






class   _SCREAMING_SNAKE_CASE   :



	def __init__(   self		:   Optional[int]			,				a__		:   Union[str, Any]			,				a__		:   int=13			,				a__		:   str=3			,				a__		:   Dict=True			,				a__		:   Optional[Any]=True			,				a__		:   Any=0.1			,				a__		:   Dict=0.1			,				a__		:   str=224			,				a__		:   int=1000			,				a__		:   Tuple=[3, 3, 6, 4]			,				a__		:   Dict=[48, 56, 112, 220]			,				):
						__magic_name__						       =    parent
						__magic_name__						       =    batch_size
						__magic_name__						       =    num_channels
						__magic_name__						       =    is_training
						__magic_name__						       =    use_labels
						__magic_name__						       =    hidden_dropout_prob
						__magic_name__						       =    attention_probs_dropout_prob
						__magic_name__						       =    num_labels
						__magic_name__						       =    image_size
						__magic_name__						       =    layer_depths
						__magic_name__						       =    embed_dims



	def 			snake_case__  (   self		:   Optional[Any]      ):
						__magic_name__						       =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

						__magic_name__						       =    None
						if self.use_labels:
											__magic_name__						       =    ids_tensor([self.batch_size]			,				self.num_labels      )

						__magic_name__						       =    self.get_config()

						return config, pixel_values, labels



	def 			snake_case__  (   self		:   List[Any]      ):
						return SwiftFormerConfig(
						    depths=self.layer_depths			,				embed_dims=self.embed_dims			,				mlp_ratio=4			,				downsamples=[True, True, True, True]			,				hidden_act='''gelu'''			,				num_labels=self.num_labels			,				down_patch_size=3			,				down_stride=2			,				down_pad=1			,				drop_rate=0.0			,				drop_path_rate=0.0			,				use_layer_scale=a__			,				layer_scale_init_value=1E-5			,				)



	def 			snake_case__  (   self		:   Tuple			,				a__		:   Optional[Any]			,				a__		:   List[Any]			,				a__		:   int      ):
						__magic_name__						       =    SwiftFormerModel(config=a__      )
						model.to(a__      )
						model.eval()
						__magic_name__						       =    model(a__      )
						self.parent.assertEqual(result.last_hidden_state.shape			,				(self.batch_size, self.embed_dims[-1], 7, 7)      )



	def 			snake_case__  (   self		:   Any			,				a__		:   Tuple			,				a__		:   str			,				a__		:   Dict      ):
						__magic_name__						       =    self.num_labels
						__magic_name__						       =    SwiftFormerForImageClassification(a__      )
						model.to(a__      )
						model.eval()
						__magic_name__						       =    model(a__			,				labels=a__      )
						self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.num_labels)      )

						__magic_name__						       =    SwiftFormerForImageClassification(a__      )
						model.to(a__      )
						model.eval()

						__magic_name__						       =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )
						__magic_name__						       =    model(a__      )
						self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.num_labels)      )



	def 			snake_case__  (   self		:   Union[str, Any]      ):
						((__magic_name__)       ,  (__magic_name__)       ,  (__magic_name__))						       =    self.prepare_config_and_inputs()
						__magic_name__						       =    {'''pixel_values''': pixel_values}
						return config, inputs_dict






@require_torch
class   _SCREAMING_SNAKE_CASE   (   __a		,__a		,unittest.TestCase     ):
	__SCREAMING_SNAKE_CASE					:Union[str, Any]      	=					(SwiftFormerModel, SwiftFormerForImageClassification) if is_torch_available() else ()
	__SCREAMING_SNAKE_CASE					:Union[str, Any]      	=					(
	    {"""feature-extraction""": SwiftFormerModel, """image-classification""": SwiftFormerForImageClassification}
	    if is_torch_available()
	    else {}
	)

	__SCREAMING_SNAKE_CASE					:Union[str, Any]      	=					False
	__SCREAMING_SNAKE_CASE					:Dict      	=					False
	__SCREAMING_SNAKE_CASE					:List[str]      	=					False
	__SCREAMING_SNAKE_CASE					:Union[str, Any]      	=					False
	__SCREAMING_SNAKE_CASE					:Optional[int]      	=					False



	def 			snake_case__  (   self		:   Optional[Any]      ):
						__magic_name__						       =    SwiftFormerModelTester(self      )
						__magic_name__						       =    ConfigTester(
						    self			,				config_class=a__			,				has_text_modality=a__			,				hidden_size=37			,				num_attention_heads=12			,				num_hidden_layers=12			,				)



	def 			snake_case__  (   self		:   Union[str, Any]      ):
						self.config_tester.run_common_tests()



	@unittest.skip(reason='''SwiftFormer does not use inputs_embeds'''      )
	def 			snake_case__  (   self		:   Tuple      ):
						pass



	def 			snake_case__  (   self		:   List[str]      ):
						__magic_name__       ,  __magic_name__						       =    self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
											__magic_name__						       =    model_class(a__      )
											__magic_name__						       =    model.get_output_embeddings()
											self.assertTrue(x is None or isinstance(a__			,				nn.Linear      )      )



	def 			snake_case__  (   self		:   str      ):
						__magic_name__       ,  __magic_name__						       =    self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
											__magic_name__						       =    model_class(a__      )
											__magic_name__						       =    inspect.signature(model.forward      )
											# signature.parameters is an OrderedDict => so arg_names order is deterministic
											__magic_name__						       =    [*signature.parameters.keys()]

											__magic_name__						       =    ['''pixel_values''']
											self.assertListEqual(arg_names[:1]			,				a__      )



	def 			snake_case__  (   self		:   Optional[Any]      ):
						__magic_name__						       =    self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*a__      )



	def 			snake_case__  (   self		:   Any      ):
						__magic_name__						       =    self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*a__      )



	@slow
	def 			snake_case__  (   self		:   List[str]      ):
						for model_name in SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__magic_name__						       =    SwiftFormerModel.from_pretrained(a__      )
											self.assertIsNotNone(a__      )



	@unittest.skip(reason='''SwiftFormer does not output attentions'''      )
	def 			snake_case__  (   self		:   Optional[int]      ):
						pass



	def 			snake_case__  (   self		:   Dict      ):
						def check_hidden_states_output(a__		:   List[Any]			,				a__		:   int			,				a__		:   List[Any]      ):
											__magic_name__						       =    model_class(a__      )
											model.to(a__      )
											model.eval()

											with torch.no_grad():
																__magic_name__						       =    model(**self._prepare_for_class(a__			,				a__      )      )

											__magic_name__						       =    outputs.hidden_states

											__magic_name__						       =    8
											self.assertEqual(len(a__      )			,				a__      )  # TODO

											# SwiftFormer's feature maps are of shape (batch_size, embed_dims, height, width)
											# with the width and height being successively divided by 2, after every 2 blocks
											for i in range(len(a__      )      ):
																self.assertEqual(
																    hidden_states[i].shape			,				torch.Size(
																        [
																            self.model_tester.batch_size,
																            self.model_tester.embed_dims[i // 2],
																            (self.model_tester.image_size // 4) // 2 ** (i // 2),
																            (self.model_tester.image_size // 4) // 2 ** (i // 2),
																        ]      )			,				)

						__magic_name__       ,  __magic_name__						       =    self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
											__magic_name__						       =    True
											check_hidden_states_output(a__			,				a__			,				a__      )

											# check that output_hidden_states also work using config
											del inputs_dict["output_hidden_states"]
											__magic_name__						       =    True

											check_hidden_states_output(a__			,				a__			,				a__      )



	def 			snake_case__  (   self		:   Union[str, Any]      ):
						def _config_zero_init(a__		:   Tuple      ):
											__magic_name__						       =    copy.deepcopy(a__      )
											for key in configs_no_init.__dict__.keys():
																if "_range" in key or "_std" in key or "initializer_factor" in key or "layer_scale" in key:
																					setattr(a__			,				a__			,				1E-10      )
																if isinstance(getattr(a__			,				a__			,				a__      )			,				a__      ):
																					__magic_name__						       =    _config_zero_init(getattr(a__			,				a__      )      )
																					setattr(a__			,				a__			,				a__      )
											return configs_no_init

						__magic_name__       ,  __magic_name__						       =    self.model_tester.prepare_config_and_inputs_for_common()

						__magic_name__						       =    _config_zero_init(a__      )
						for model_class in self.all_model_classes:
											__magic_name__						       =    model_class(config=a__      )
											for name, param in model.named_parameters():
																if param.requires_grad:
																					self.assertIn(
																					    ((param.data.mean() * 1E9) / 1E9).round().item()			,				[0.0, 1.0]			,				msg=F'''Parameter {name} of model {model_class} seems not properly initialized'''			,				)



	@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''      )
	def 			snake_case__  (   self		:   int      ):
						pass




def 						UpperCamelCase	(			)				->     str:






					'''simple docstring'''
					__magic_name__						       =    Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''			)
					return image






@require_torch
@require_vision
class   _SCREAMING_SNAKE_CASE   (   unittest.TestCase     ):



	@cached_property
	def 			snake_case__  (   self		:   List[str]      ):
						return ViTImageProcessor.from_pretrained('''MBZUAI/swiftformer-xs'''      ) if is_vision_available() else None



	@slow
	def 			snake_case__  (   self		:   Dict      ):
						__magic_name__						       =    SwiftFormerForImageClassification.from_pretrained('''MBZUAI/swiftformer-xs'''      ).to(a__      )

						__magic_name__						       =    self.default_image_processor
						__magic_name__						       =    prepare_img()
						__magic_name__						       =    image_processor(images=a__			,				return_tensors='''pt'''      ).to(a__      )

						# forward pass
						with torch.no_grad():
											__magic_name__						       =    model(**a__      )

						# verify the logits
						__magic_name__						       =    torch.Size((1, 1000)      )
						self.assertEqual(outputs.logits.shape			,				a__      )

						__magic_name__						       =    torch.tensor([[-2.1703E00, 2.1107E00, -2.0811E00]]      ).to(a__      )
						self.assertTrue(torch.allclose(outputs.logits[0, :3]			,				a__			,				atol=1E-4      )      )









'''simple docstring'''




from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxSeqaSeqConfigWithPast
from ...utils import logging


if TYPE_CHECKING:
      from ...feature_extraction_utils import FeatureExtractionMixin
      from ...tokenization_utils_base import PreTrainedTokenizerBase
      from ...utils import TensorType

_lowerCAmelCase         =						logging.get_logger(__name__)

_lowerCAmelCase         =						{
    "openai/whisper-base": "https://huggingface.co/openai/whisper-base/resolve/main/config.json",
}

# fmt: off
_lowerCAmelCase         =						[
    1, 2, 7, 8, 9, 10, 14, 25,
    26, 27, 28, 29, 31, 58, 59, 60, 61, 62,
    63, 90, 91, 92, 93, 357, 366, 438, 532, 685,
    705, 796, 930, 1058, 1220, 1267, 1279, 1303, 1343, 1377,
    1391, 1635, 1782, 1875, 2162, 2361, 2488, 3467, 4008, 4211,
    4600, 4808, 5299, 5855, 6329, 7203, 9609, 9959, 10563, 10786,
    11420, 11709, 11907, 13163, 13697, 13700, 14808, 15306, 16410, 16791,
    17992, 19203, 19510, 20724, 22305, 22935, 27007, 30109, 30420, 33409,
    34949, 40283, 40493, 40549, 47282, 49146, 50257, 50359, 50360, 50361
]
_lowerCAmelCase         =						[
    1, 2, 7, 8, 9, 10, 14, 25,
    26, 27, 28, 29, 31, 58, 59, 60, 61, 62,
    63, 90, 91, 92, 93, 359, 503, 522, 542, 873,
    893, 902, 918, 922, 931, 1350, 1853, 1982, 2460, 2627,
    3246, 3253, 3268, 3536, 3846, 3961, 4183, 4667, 6585, 6647,
    7273, 9061, 9383, 10428, 10929, 11938, 12033, 12331, 12562, 13793,
    14157, 14635, 15265, 15618, 16553, 16604, 18362, 18956, 20075, 21675,
    22520, 26130, 26161, 26435, 28279, 29464, 31650, 32302, 32470, 36865,
    42863, 47425, 49870, 50254, 50258, 50360, 50361, 50362
]






class   _SCREAMING_SNAKE_CASE   (   __a     ):
 __SCREAMING_SNAKE_CASE					:str      	=					"""whisper"""
 __SCREAMING_SNAKE_CASE					:str      	=					["""past_key_values"""]
 __SCREAMING_SNAKE_CASE					:Tuple      	=					{"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""}



 def __init__(   self		:   Dict			,				a__		:   Optional[int]=5_1865			,				a__		:   str=80			,				a__		:   List[str]=6			,				a__		:   List[str]=4			,				a__		:   List[Any]=6			,				a__		:   Union[str, Any]=4			,				a__		:   Tuple=1536			,				a__		:   Optional[int]=1536			,				a__		:   List[str]=0.0			,				a__		:   Union[str, Any]=0.0			,				a__		:   Union[str, Any]=5_0257			,				a__		:   Dict=True			,				a__		:   Optional[Any]=True			,				a__		:   Union[str, Any]="gelu"			,				a__		:   Tuple=256			,				a__		:   Dict=0.0			,				a__		:   str=0.0			,				a__		:   Optional[Any]=0.0			,				a__		:   int=0.02			,				a__		:   Any=False			,				a__		:   List[Any]=1500			,				a__		:   Optional[int]=448			,				a__		:   Dict=5_0256			,				a__		:   str=5_0256			,				a__		:   Tuple=5_0256			,				a__		:   List[str]=None			,				a__		:   List[Any]=[220, 5_0256]			,				a__		:   Any=False			,				a__		:   Dict=256			,				a__		:   Optional[Any]=False			,				a__		:   str=0.05			,				a__		:   List[Any]=10			,				a__		:   List[Any]=2			,				a__		:   Optional[int]=0.0			,				a__		:   List[Any]=10			,				a__		:   Union[str, Any]=0			,				a__		:   int=7			,				**a__		:   Any			,				):
      __magic_name__						       =    vocab_size
      __magic_name__						       =    num_mel_bins
      __magic_name__						       =    d_model
      __magic_name__						       =    encoder_layers
      __magic_name__						       =    encoder_attention_heads
      __magic_name__						       =    decoder_layers
      __magic_name__						       =    decoder_attention_heads
      __magic_name__						       =    decoder_ffn_dim
      __magic_name__						       =    encoder_ffn_dim
      __magic_name__						       =    dropout
      __magic_name__						       =    attention_dropout
      __magic_name__						       =    activation_dropout
      __magic_name__						       =    activation_function
      __magic_name__						       =    init_std
      __magic_name__						       =    encoder_layerdrop
      __magic_name__						       =    decoder_layerdrop
      __magic_name__						       =    use_cache
      __magic_name__						       =    encoder_layers
      __magic_name__						       =    scale_embedding  # scale factor will be sqrt(d_model) if True
      __magic_name__						       =    max_source_positions
      __magic_name__						       =    max_target_positions

      # Audio Classification-specific parameters. Feel free to ignore for other classes.
      __magic_name__						       =    classifier_proj_size
      __magic_name__						       =    use_weighted_layer_sum

      # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
      __magic_name__						       =    apply_spec_augment
      __magic_name__						       =    mask_time_prob
      __magic_name__						       =    mask_time_length
      __magic_name__						       =    mask_time_min_masks
      __magic_name__						       =    mask_feature_prob
      __magic_name__						       =    mask_feature_length
      __magic_name__						       =    mask_feature_min_masks

      __magic_name__						       =    median_filter_width

      super().__init__(
          pad_token_id=a__			,				bos_token_id=a__			,				eos_token_id=a__			,				is_encoder_decoder=a__			,				decoder_start_token_id=a__			,				suppress_tokens=a__			,				begin_suppress_tokens=a__			,				**a__			,				)






class   _SCREAMING_SNAKE_CASE   (   __a     ):



 @property
 def 			snake_case__  (   self		:   List[str]      ):
      __magic_name__						       =    OrderedDict(
          [
              ('''input_features''', {0: '''batch''', 1: '''feature_size''', 2: '''encoder_sequence'''}),
          ]      )
      if self.use_past:
           __magic_name__						       =    {0: '''batch'''}
      else:
           __magic_name__						       =    {0: '''batch''', 1: '''decoder_sequence'''}

      if self.use_past:
           self.fill_with_past_key_values_(a__			,				direction='''inputs'''      )

      return common_inputs



 def 			snake_case__  (   self		:   Optional[int]			,				a__		:   Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"]			,				a__		:   int = -1			,				a__		:   int = -1			,				a__		:   bool = False			,				a__		:   Optional["TensorType"] = None			,				a__		:   int = 2_2050			,				a__		:   float = 5.0			,				a__		:   int = 220			,				):
      __magic_name__						       =    OrderedDict()
      __magic_name__						       =    OnnxConfig.generate_dummy_inputs(
          self			,				preprocessor=preprocessor.feature_extractor			,				batch_size=a__			,				framework=a__			,				sampling_rate=a__			,				time_duration=a__			,				frequency=a__			,				)
      __magic_name__						       =    encoder_inputs['''input_features'''].shape[2]
      __magic_name__						       =    encoder_sequence_length // 2 if self.use_past else seq_length

      __magic_name__						       =    super().generate_dummy_inputs(
          preprocessor.tokenizer			,				a__			,				a__			,				a__			,				a__      )

      __magic_name__						       =    encoder_inputs.pop('''input_features'''      )
      __magic_name__						       =    decoder_inputs.pop('''decoder_input_ids'''      )

      if "past_key_values" in decoder_inputs:
           __magic_name__						       =    decoder_inputs.pop('''past_key_values'''      )

      return dummy_inputs



 @property
 def 			snake_case__  (   self		:   Dict      ):
      return 1E-3






