






"""simple docstring"""



import collections
import inspect
import unittest

from transformers import SwinConfig
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_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch
    from torch import nn

    from transformers import SwinBackbone, SwinForImageClassification, SwinForMaskedImageModeling, SwinModel
    from transformers.models.swin.modeling_swin import SWIN_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import AutoImageProcessor

class 			a	:







    def __init__(     self				,						_lowerCamelCase				,						_lowerCamelCase=1_3				,						_lowerCamelCase=3_2				,						_lowerCamelCase=2				,						_lowerCamelCase=3				,						_lowerCamelCase=1_6				,						_lowerCamelCase=[1, 2, 1]				,						_lowerCamelCase=[2, 2, 4]				,						_lowerCamelCase=2				,						_lowerCamelCase=2.0				,						_lowerCamelCase=True				,						_lowerCamelCase=0.0				,						_lowerCamelCase=0.0				,						_lowerCamelCase=0.1				,						_lowerCamelCase="gelu"				,						_lowerCamelCase=False				,						_lowerCamelCase=True				,						_lowerCamelCase=0.0_2				,						_lowerCamelCase=1e-5				,						_lowerCamelCase=True				,						_lowerCamelCase=None				,						_lowerCamelCase=True				,						_lowerCamelCase=1_0				,						_lowerCamelCase=8				,						_lowerCamelCase=["stage1", "stage2"]				,						_lowerCamelCase=[1, 2]				,						):
      lowercase				       =			parent
      lowercase				       =			batch_size
      lowercase				       =			image_size
      lowercase				       =			patch_size
      lowercase				       =			num_channels
      lowercase				       =			embed_dim
      lowercase				       =			depths
      lowercase				       =			num_heads
      lowercase				       =			window_size
      lowercase				       =			mlp_ratio
      lowercase				       =			qkv_bias
      lowercase				       =			hidden_dropout_prob
      lowercase				       =			attention_probs_dropout_prob
      lowercase				       =			drop_path_rate
      lowercase				       =			hidden_act
      lowercase				       =			use_absolute_embeddings
      lowercase				       =			patch_norm
      lowercase				       =			layer_norm_eps
      lowercase				       =			initializer_range
      lowercase				       =			is_training
      lowercase				       =			scope
      lowercase				       =			use_labels
      lowercase				       =			type_sequence_label_size
      lowercase				       =			encoder_stride
      lowercase				       =			out_features
      lowercase				       =			out_indices







    def      UpperCamelCase_ (     self			):
      lowercase				       =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

      lowercase				       =			None
      if self.use_labels:
        lowercase				       =			ids_tensor([self.batch_size]				,						self.type_sequence_label_size			)

      lowercase				       =			self.get_config()

      return config, pixel_values, labels







    def      UpperCamelCase_ (     self			):
      return SwinConfig(
          image_size=self.image_size				,						patch_size=self.patch_size				,						num_channels=self.num_channels				,						embed_dim=self.embed_dim				,						depths=self.depths				,						num_heads=self.num_heads				,						window_size=self.window_size				,						mlp_ratio=self.mlp_ratio				,						qkv_bias=self.qkv_bias				,						hidden_dropout_prob=self.hidden_dropout_prob				,						attention_probs_dropout_prob=self.attention_probs_dropout_prob				,						drop_path_rate=self.drop_path_rate				,						hidden_act=self.hidden_act				,						use_absolute_embeddings=self.use_absolute_embeddings				,						path_norm=self.patch_norm				,						layer_norm_eps=self.layer_norm_eps				,						initializer_range=self.initializer_range				,						encoder_stride=self.encoder_stride				,						out_features=self.out_features				,						out_indices=self.out_indices				,						)







    def      UpperCamelCase_ (     self				,						_lowerCamelCase				,						_lowerCamelCase				,						_lowerCamelCase			):
      lowercase				       =			SwinModel(config=snake_case__			)
      model.to(snake_case__			)
      model.eval()
      lowercase				       =			model(snake_case__			)

      lowercase				       =			((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths			) - 1))
      lowercase				       =			int(config.embed_dim * 2 ** (len(config.depths			) - 1)			)

      self.parent.assertEqual(result.last_hidden_state.shape				,						(self.batch_size, expected_seq_len, expected_dim)			)







    def      UpperCamelCase_ (     self				,						_lowerCamelCase				,						_lowerCamelCase				,						_lowerCamelCase			):
      lowercase				       =			SwinBackbone(config=snake_case__			)
      model.to(snake_case__			)
      model.eval()
      lowercase				       =			model(snake_case__			)

      # verify hidden states
      self.parent.assertEqual(len(result.feature_maps			)				,						len(config.out_features			)			)
      self.parent.assertListEqual(list(result.feature_maps[0].shape			)				,						[self.batch_size, model.channels[0], 1_6, 1_6]			)

      # verify channels
      self.parent.assertEqual(len(model.channels			)				,						len(config.out_features			)			)

      # verify backbone works with out_features=None
      lowercase				       =			None
      lowercase				       =			SwinBackbone(config=snake_case__			)
      model.to(snake_case__			)
      model.eval()
      lowercase				       =			model(snake_case__			)

      # verify feature maps
      self.parent.assertEqual(len(result.feature_maps			)				,						1			)
      self.parent.assertListEqual(list(result.feature_maps[0].shape			)				,						[self.batch_size, model.channels[-1], 4, 4]			)

      # verify channels
      self.parent.assertEqual(len(model.channels			)				,						1			)







    def      UpperCamelCase_ (     self				,						_lowerCamelCase				,						_lowerCamelCase				,						_lowerCamelCase			):
      lowercase				       =			SwinForMaskedImageModeling(config=snake_case__			)
      model.to(snake_case__			)
      model.eval()
      lowercase				       =			model(snake_case__			)
      self.parent.assertEqual(
          result.logits.shape				,						(self.batch_size, self.num_channels, self.image_size, self.image_size)			)

      # test greyscale images
      lowercase				       =			1
      lowercase				       =			SwinForMaskedImageModeling(snake_case__			)
      model.to(snake_case__			)
      model.eval()

      lowercase				       =			floats_tensor([self.batch_size, 1, self.image_size, self.image_size]			)
      lowercase				       =			model(snake_case__			)
      self.parent.assertEqual(result.logits.shape				,						(self.batch_size, 1, self.image_size, self.image_size)			)







    def      UpperCamelCase_ (     self				,						_lowerCamelCase				,						_lowerCamelCase				,						_lowerCamelCase			):
      lowercase				       =			self.type_sequence_label_size
      lowercase				       =			SwinForImageClassification(snake_case__			)
      model.to(snake_case__			)
      model.eval()
      lowercase				       =			model(snake_case__				,						labels=snake_case__			)
      self.parent.assertEqual(result.logits.shape				,						(self.batch_size, self.type_sequence_label_size)			)

      # test greyscale images
      lowercase				       =			1
      lowercase				       =			SwinForImageClassification(snake_case__			)
      model.to(snake_case__			)
      model.eval()

      lowercase				       =			floats_tensor([self.batch_size, 1, self.image_size, self.image_size]			)
      lowercase				       =			model(snake_case__			)
      self.parent.assertEqual(result.logits.shape				,						(self.batch_size, self.type_sequence_label_size)			)







    def      UpperCamelCase_ (     self			):
      lowercase				       =			self.prepare_config_and_inputs()
      (
          lowercase    
      )				       =			config_and_inputs
      lowercase				       =			{'''pixel_values''': pixel_values}
      return config, inputs_dict


@require_torch
class 			a	(  lowerCamelCase__,							lowerCamelCase__,							unittest.TestCase      ):
    UpperCAmelCase_					:	List[str]      	=(
        (
            SwinModel,
            SwinBackbone,
            SwinForImageClassification,
            SwinForMaskedImageModeling,
        )
        if is_torch_available()
        else ()
    )
    UpperCAmelCase_					:	Union[str, Any]      	=(
        {"""feature-extraction""": SwinModel, """image-classification""": SwinForImageClassification}
        if is_torch_available()
        else {}
    )
    UpperCAmelCase_					:	Union[str, Any]      	=True

    UpperCAmelCase_					:	Tuple      	=False
    UpperCAmelCase_					:	Tuple      	=False
    UpperCAmelCase_					:	Any      	=False







    def      UpperCamelCase_ (     self			):
      lowercase				       =			SwinModelTester(self			)
      lowercase				       =			ConfigTester(self				,						config_class=snake_case__				,						embed_dim=3_7			)







    def      UpperCamelCase_ (     self			):
      self.create_and_test_config_common_properties()
      self.config_tester.create_and_test_config_to_json_string()
      self.config_tester.create_and_test_config_to_json_file()
      self.config_tester.create_and_test_config_from_and_save_pretrained()
      self.config_tester.create_and_test_config_with_num_labels()
      self.config_tester.check_config_can_be_init_without_params()
      self.config_tester.check_config_arguments_init()







    def      UpperCamelCase_ (     self			):
      return







    def      UpperCamelCase_ (     self			):
      lowercase				       =			self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*snake_case__			)







    @unittest.skip(reason='Got `CUDA error: misaligned address` with PyTorch 2.0.0.'			)
    def      UpperCamelCase_ (     self			):
      pass







    def      UpperCamelCase_ (     self			):
      super().test_training_gradient_checkpointing()







    def      UpperCamelCase_ (     self			):
      lowercase				       =			self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_backbone(*snake_case__			)







    def      UpperCamelCase_ (     self			):
      lowercase				       =			self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_image_modeling(*snake_case__			)







    def      UpperCamelCase_ (     self			):
      lowercase				       =			self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*snake_case__			)







    @unittest.skip(reason='Swin does not use inputs_embeds'			)
    def      UpperCamelCase_ (     self			):
      pass







    @unittest.skip(reason='Swin Transformer does not use feedforward chunking'			)
    def      UpperCamelCase_ (     self			):
      pass







    def      UpperCamelCase_ (     self			):
      lowercase				       =			self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        lowercase				       =			model_class(snake_case__			)
        self.assertIsInstance(model.get_input_embeddings()				,						(nn.Module)			)
        lowercase				       =			model.get_output_embeddings()
        self.assertTrue(x is None or isinstance(snake_case__				,						nn.Linear			)			)







    def      UpperCamelCase_ (     self			):
      lowercase				       =			self.model_tester.prepare_config_and_inputs_for_common()

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

        lowercase				       =			['''pixel_values''']
        self.assertListEqual(arg_names[:1]				,						snake_case__			)







    def      UpperCamelCase_ (     self			):
      lowercase				       =			self.model_tester.prepare_config_and_inputs_for_common()
      lowercase				       =			True

      for model_class in self.all_model_classes:
        lowercase				       =			True
        lowercase				       =			False
        lowercase				       =			True
        lowercase				       =			model_class(snake_case__			)
        model.to(snake_case__			)
        model.eval()
        with torch.no_grad():
          lowercase				       =			model(**self._prepare_for_class(snake_case__				,						snake_case__			)			)
        lowercase				       =			outputs.attentions
        lowercase				       =			len(self.model_tester.depths			)
        self.assertEqual(len(snake_case__			)				,						snake_case__			)

        # check that output_attentions also work using config
        del inputs_dict["output_attentions"]
        lowercase				       =			True
        lowercase				       =			config.window_size**2
        lowercase				       =			model_class(snake_case__			)
        model.to(snake_case__			)
        model.eval()
        with torch.no_grad():
          lowercase				       =			model(**self._prepare_for_class(snake_case__				,						snake_case__			)			)
        lowercase				       =			outputs.attentions
        self.assertEqual(len(snake_case__			)				,						snake_case__			)

        self.assertListEqual(
            list(attentions[0].shape[-3:]			)				,						[self.model_tester.num_heads[0], window_size_squared, window_size_squared]				,						)
        lowercase				       =			len(snake_case__			)

        # Check attention is always last and order is fine
        lowercase				       =			True
        lowercase				       =			True
        lowercase				       =			model_class(snake_case__			)
        model.to(snake_case__			)
        model.eval()
        with torch.no_grad():
          lowercase				       =			model(**self._prepare_for_class(snake_case__				,						snake_case__			)			)

        # also another +1 for reshaped_hidden_states
        lowercase				       =			1 if model_class.__name__ == '''SwinBackbone''' else 2
        self.assertEqual(out_len + added_hidden_states				,						len(snake_case__			)			)

        lowercase				       =			outputs.attentions

        self.assertEqual(len(snake_case__			)				,						snake_case__			)

        self.assertListEqual(
            list(self_attentions[0].shape[-3:]			)				,						[self.model_tester.num_heads[0], window_size_squared, window_size_squared]				,						)







    def      UpperCamelCase_ (     self				,						_lowerCamelCase				,						_lowerCamelCase				,						_lowerCamelCase				,						_lowerCamelCase			):
      lowercase				       =			model_class(snake_case__			)
      model.to(snake_case__			)
      model.eval()

      with torch.no_grad():
        lowercase				       =			model(**self._prepare_for_class(snake_case__				,						snake_case__			)			)

      lowercase				       =			outputs.hidden_states

      lowercase				       =			getattr(
          self.model_tester				,						'expected_num_hidden_layers'				,						len(self.model_tester.depths			) + 1			)
      self.assertEqual(len(snake_case__			)				,						snake_case__			)

      # Swin has a different seq_length
      lowercase				       =			(
          config.patch_size
          if isinstance(config.patch_size				,						collections.abc.Iterable			)
          else (config.patch_size, config.patch_size)
      )

      lowercase				       =			(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

      self.assertListEqual(
          list(hidden_states[0].shape[-2:]			)				,						[num_patches, self.model_tester.embed_dim]				,						)

      if not model_class.__name__ == "SwinBackbone":
        lowercase				       =			outputs.reshaped_hidden_states
        self.assertEqual(len(snake_case__			)				,						snake_case__			)

        lowercase				       =			reshaped_hidden_states[0].shape
        lowercase				       =			(
            reshaped_hidden_states[0].view(snake_case__				,						snake_case__				,						height * width			).permute(0				,						2				,						1			)
        )
        self.assertListEqual(
            list(reshaped_hidden_states.shape[-2:]			)				,						[num_patches, self.model_tester.embed_dim]				,						)







    def      UpperCamelCase_ (     self			):
      lowercase				       =			self.model_tester.prepare_config_and_inputs_for_common()

      lowercase				       =			(
          self.model_tester.image_size
          if isinstance(self.model_tester.image_size				,						collections.abc.Iterable			)
          else (self.model_tester.image_size, self.model_tester.image_size)
      )

      for model_class in self.all_model_classes:
        lowercase				       =			True
        self.check_hidden_states_output(snake_case__				,						snake_case__				,						snake_case__				,						snake_case__			)

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

        self.check_hidden_states_output(snake_case__				,						snake_case__				,						snake_case__				,						snake_case__			)







    def      UpperCamelCase_ (     self			):
      lowercase				       =			self.model_tester.prepare_config_and_inputs_for_common()
      lowercase				       =			3

      lowercase				       =			(
          self.model_tester.image_size
          if isinstance(self.model_tester.image_size				,						collections.abc.Iterable			)
          else (self.model_tester.image_size, self.model_tester.image_size)
      )
      lowercase				       =			(
          config.patch_size
          if isinstance(config.patch_size				,						collections.abc.Iterable			)
          else (config.patch_size, config.patch_size)
      )

      lowercase				       =			image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
      lowercase				       =			image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

      for model_class in self.all_model_classes:
        lowercase				       =			True
        self.check_hidden_states_output(snake_case__				,						snake_case__				,						snake_case__				,						(padded_height, padded_width)			)

        # check that output_hidden_states also work using config
        del inputs_dict["output_hidden_states"]
        lowercase				       =			True
        self.check_hidden_states_output(snake_case__				,						snake_case__				,						snake_case__				,						(padded_height, padded_width)			)







    @slow
    def      UpperCamelCase_ (     self			):





      for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        lowercase				       =			SwinModel.from_pretrained(snake_case__			)
        self.assertIsNotNone(snake_case__			)







    def      UpperCamelCase_ (     self			):
      lowercase				       =			self.model_tester.prepare_config_and_inputs_for_common()

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


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







    @cached_property
    def      UpperCamelCase_ (     self			):
      return (
          AutoImageProcessor.from_pretrained('microsoft/swin-tiny-patch4-window7-224'			)
          if is_vision_available()
          else None
      )







    @slow
    def      UpperCamelCase_ (     self			):
      lowercase				       =			SwinForImageClassification.from_pretrained('microsoft/swin-tiny-patch4-window7-224'			).to(snake_case__			)
      lowercase				       =			self.default_image_processor

      lowercase				       =			Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'			)
      lowercase				       =			image_processor(images=snake_case__				,						return_tensors='pt'			).to(snake_case__			)

      # forward pass
      with torch.no_grad():
        lowercase				       =			model(**snake_case__			)

      # verify the logits
      lowercase				       =			torch.Size((1, 1_0_0_0)			)
      self.assertEqual(outputs.logits.shape				,						snake_case__			)
      lowercase				       =			torch.tensor([-0.0_9_4_8, -0.6_4_5_4, -0.0_9_2_1]			).to(snake_case__			)
      self.assertTrue(torch.allclose(outputs.logits[0, :3]				,						snake_case__				,						atol=1e-4			)			)


@require_torch
class 			a	(  unittest.TestCase,							lowerCamelCase__      ):
    UpperCAmelCase_					:	Tuple      	=(SwinBackbone,) if is_torch_available() else ()
    UpperCAmelCase_					:	List[str]      	=SwinConfig







    def      UpperCamelCase_ (     self			):
      lowercase				       =			SwinModelTester(self			)



import inspect
import json
import os
import tempfile
import unittest

from transformers.models.speech_to_text_a import SpeechaTextaTokenizer
from transformers.models.speech_to_text_a.tokenization_speech_to_text_a import VOCAB_FILES_NAMES

from ...test_tokenization_common import TokenizerTesterMixin







class       __snake_case (  lowerCamelCase__       , unittest.TestCase ):
 __lowerCamelCase     : Any 	=   SpeechaTextaTokenizer
 __lowerCamelCase     : Tuple 	=   False
 def 						UpperCAmelCase__							(	self    )						->				List[Any]:
       '''simple docstring'''





       super().setUp()

       UpperCAmelCase     :			Union[str, Any]     	='''<s> <pad> </s> <unk> here@@ a couple of@@ words for the he@@ re@@ vocab'''.split(''' '''    )
       UpperCAmelCase     :			int     	=['''he re</w> 123''', '''here a 1456''']
       UpperCAmelCase     :			int     	=dict(zip(snake_case__		, range(len(snake_case__    )    )    )    )

       UpperCAmelCase     :			Tuple     	={'''pad_token''': '''<pad>''', '''unk_token''': '''<unk>''', '''bos_token''': '''<s>''', '''eos_token''': '''</s>'''}

       UpperCAmelCase     :			Tuple     	=tempfile.mkdtemp()
       UpperCAmelCase     :			Optional[Any]     	=os.path.join(self.tmpdirname		, VOCAB_FILES_NAMES['''vocab_file''']    )
       UpperCAmelCase     :			Dict     	=os.path.join(self.tmpdirname		, VOCAB_FILES_NAMES['''merges_file''']    )

       with open(self.vocab_file		, '''w'''		, encoding='''utf-8'''    ) as fp:
             fp.write(json.dumps(snake_case__    ) + '''\n'''    )

       with open(self.merges_file		, '''w'''    ) as fp:
             fp.write('''\n'''.join(snake_case__    )    )
 def 						UpperCAmelCase__							(	self    )						->				Union[str, Any]:
       '''simple docstring'''





       UpperCAmelCase     :			Union[str, Any]     	=list(self.get_tokenizer().get_vocab().keys()    )

       self.assertEqual(vocab_keys[0]		, '''<s>'''    )
       self.assertEqual(vocab_keys[1]		, '''<pad>'''    )
       self.assertEqual(vocab_keys[-1]		, '''vocab'''    )
       self.assertEqual(len(snake_case__    )		, 14    )
 def 						UpperCAmelCase__							(	self    )						->				Union[str, Any]:
       '''simple docstring'''





       self.assertEqual(self.get_tokenizer().vocab_size		, 14    )
 def 						UpperCAmelCase__							(	self    )						->				List[Any]:
       '''simple docstring'''





       UpperCAmelCase     :			Union[str, Any]     	=SpeechaTextaTokenizer.from_pretrained(self.tmpdirname    )

       # make sure @@ is correctly concatenated
       UpperCAmelCase     :			str     	=[4, 6, 8, 7, 10]  # ["here@@", "couple", "words", "of@@", "the"]
       UpperCAmelCase     :			Optional[Any]     	=tokenizer.decode(snake_case__    )

       self.assertTrue(output_string == '''herecouple words ofthe'''    )
 def 						UpperCAmelCase__							(	self    )						->				Tuple:
       '''simple docstring'''





       UpperCAmelCase     :			Optional[Any]     	=SpeechaTextaTokenizer.from_pretrained(self.tmpdirname    )

       with tempfile.TemporaryDirectory() as tmp_dirname:
             tokenizer.save_pretrained(snake_case__    )
             os.remove(os.path.join(snake_case__		, '''merges.txt'''    )    )

             # load tokenizer without merges file should not throw an error
             UpperCAmelCase     :			Any     	=SpeechaTextaTokenizer.from_pretrained(snake_case__    )

       with tempfile.TemporaryDirectory() as tmp_dirname:
             # save tokenizer and load again
             tokenizer.save_pretrained(snake_case__    )
             UpperCAmelCase     :			List[str]     	=SpeechaTextaTokenizer.from_pretrained(snake_case__    )

       self.assertIsNotNone(snake_case__    )






 def 						UpperCAmelCase__							(	self    )						->				int:
       '''simple docstring'''





       if not self.test_slow_tokenizer:
             return

       UpperCAmelCase     :			List[str]     	=inspect.signature(self.tokenizer_class.__init__    )
       UpperCAmelCase     :			Union[str, Any]     	=self.get_tokenizer()

       for parameter_name, parameter in signature.parameters.items():
             if parameter.default != inspect.Parameter.empty and parameter_name != "merges_file":
                   self.assertIn(snake_case__		, tokenizer.init_kwargs    )
