
import os
import unittest

from transformers import ElectraTokenizerFast
from transformers.models.electra.tokenization_electra import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    ElectraTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english


@require_tokenizers
class 			UpperCamelCase_				(  A					,       unittest.TestCase     ):




      '''simple docstring'''







      a		:int						 =      ElectraTokenizer
      a		:str						 =      ElectraTokenizerFast
      a		:List[Any]						 =      True
      a		:Union[str, Any]						 =      True
      a		:List[Any]						 =      filter_non_english







      def lowercase__		( self):
            super().setUp()

            lowerCAmelCase_						=      [
                '''[UNK]''',
                '''[CLS]''',
                '''[SEP]''',
                '''[PAD]''',
                '''[MASK]''',
                '''want''',
                '''##want''',
                '''##ed''',
                '''wa''',
                '''un''',
                '''runn''',
                '''##ing''',
                ''',''',
                '''low''',
                '''lowest''',
            ]
            lowerCAmelCase_						=      os.path.join(self.tmpdirname					,					VOCAB_FILES_NAMES['''vocab_file'''])
            with open(self.vocab_file					,					'''w'''					,					encoding='''utf-8''') as vocab_writer:
                  vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]))







      def lowercase__		( self					,					_UpperCAmelCase):
            lowerCAmelCase_						=      '''UNwant\u00E9d,running'''
            lowerCAmelCase_						=      '''unwanted, running'''
            return input_text, output_text







      def lowercase__		( self):
            lowerCAmelCase_						=      self.tokenizer_class(self.vocab_file)

            lowerCAmelCase_						=      tokenizer.tokenize('''UNwant\u00E9d,running''')
            self.assertListEqual(_UpperCAmelCase					,					['''un''', '''##want''', '''##ed''', ''',''', '''runn''', '''##ing'''])
            self.assertListEqual(tokenizer.convert_tokens_to_ids(_UpperCAmelCase)					,					[9, 6, 7, 12, 10, 11])







      def lowercase__		( self):
            if not self.test_rust_tokenizer:
                  return

            lowerCAmelCase_						=      self.get_tokenizer()
            lowerCAmelCase_						=      self.get_rust_tokenizer()

            lowerCAmelCase_						=      '''UNwant\u00E9d,running'''

            lowerCAmelCase_						=      tokenizer.tokenize(_UpperCAmelCase)
            lowerCAmelCase_						=      rust_tokenizer.tokenize(_UpperCAmelCase)
            self.assertListEqual(_UpperCAmelCase					,					_UpperCAmelCase)

            lowerCAmelCase_						=      tokenizer.encode(_UpperCAmelCase					,					add_special_tokens=_UpperCAmelCase)
            lowerCAmelCase_						=      rust_tokenizer.encode(_UpperCAmelCase					,					add_special_tokens=_UpperCAmelCase)
            self.assertListEqual(_UpperCAmelCase					,					_UpperCAmelCase)

            lowerCAmelCase_						=      self.get_rust_tokenizer()
            lowerCAmelCase_						=      tokenizer.encode(_UpperCAmelCase)
            lowerCAmelCase_						=      rust_tokenizer.encode(_UpperCAmelCase)
            self.assertListEqual(_UpperCAmelCase					,					_UpperCAmelCase)

            # With lower casing
            lowerCAmelCase_						=      self.get_tokenizer(do_lower_case=_UpperCAmelCase)
            lowerCAmelCase_						=      self.get_rust_tokenizer(do_lower_case=_UpperCAmelCase)

            lowerCAmelCase_						=      '''UNwant\u00E9d,running'''

            lowerCAmelCase_						=      tokenizer.tokenize(_UpperCAmelCase)
            lowerCAmelCase_						=      rust_tokenizer.tokenize(_UpperCAmelCase)
            self.assertListEqual(_UpperCAmelCase					,					_UpperCAmelCase)

            lowerCAmelCase_						=      tokenizer.encode(_UpperCAmelCase					,					add_special_tokens=_UpperCAmelCase)
            lowerCAmelCase_						=      rust_tokenizer.encode(_UpperCAmelCase					,					add_special_tokens=_UpperCAmelCase)
            self.assertListEqual(_UpperCAmelCase					,					_UpperCAmelCase)

            lowerCAmelCase_						=      self.get_rust_tokenizer()
            lowerCAmelCase_						=      tokenizer.encode(_UpperCAmelCase)
            lowerCAmelCase_						=      rust_tokenizer.encode(_UpperCAmelCase)
            self.assertListEqual(_UpperCAmelCase					,					_UpperCAmelCase)







      def lowercase__		( self):
            lowerCAmelCase_						=      BasicTokenizer()

            self.assertListEqual(tokenizer.tokenize('''ah\u535A\u63A8zz''')					,					['''ah''', '''\u535A''', '''\u63A8''', '''zz'''])







      def lowercase__		( self):
            lowerCAmelCase_						=      BasicTokenizer(do_lower_case=_UpperCAmelCase)

            self.assertListEqual(
                tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  ''')					,					['''hello''', '''!''', '''how''', '''are''', '''you''', '''?'''])
            self.assertListEqual(tokenizer.tokenize('''H\u00E9llo''')					,					['''hello'''])







      def lowercase__		( self):
            lowerCAmelCase_						=      BasicTokenizer(do_lower_case=_UpperCAmelCase					,					strip_accents=_UpperCAmelCase)

            self.assertListEqual(
                tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  ''')					,					['''hällo''', '''!''', '''how''', '''are''', '''you''', '''?'''])
            self.assertListEqual(tokenizer.tokenize('''H\u00E9llo''')					,					['''h\u00E9llo'''])







      def lowercase__		( self):
            lowerCAmelCase_						=      BasicTokenizer(do_lower_case=_UpperCAmelCase					,					strip_accents=_UpperCAmelCase)

            self.assertListEqual(
                tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  ''')					,					['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?'''])
            self.assertListEqual(tokenizer.tokenize('''H\u00E9llo''')					,					['''hello'''])







      def lowercase__		( self):
            lowerCAmelCase_						=      BasicTokenizer(do_lower_case=_UpperCAmelCase)

            self.assertListEqual(
                tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  ''')					,					['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?'''])
            self.assertListEqual(tokenizer.tokenize('''H\u00E9llo''')					,					['''hello'''])







      def lowercase__		( self):
            lowerCAmelCase_						=      BasicTokenizer(do_lower_case=_UpperCAmelCase)

            self.assertListEqual(
                tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  ''')					,					['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?'''])







      def lowercase__		( self):
            lowerCAmelCase_						=      BasicTokenizer(do_lower_case=_UpperCAmelCase					,					strip_accents=_UpperCAmelCase)

            self.assertListEqual(
                tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  ''')					,					['''HäLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?'''])







      def lowercase__		( self):
            lowerCAmelCase_						=      BasicTokenizer(do_lower_case=_UpperCAmelCase					,					strip_accents=_UpperCAmelCase)

            self.assertListEqual(
                tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  ''')					,					['''HaLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?'''])







      def lowercase__		( self):
            lowerCAmelCase_						=      BasicTokenizer(do_lower_case=_UpperCAmelCase					,					never_split=['''[UNK]'''])

            self.assertListEqual(
                tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU? [UNK]''')					,					['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''', '''[UNK]'''])







      def lowercase__		( self):
            lowerCAmelCase_						=      ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''']

            lowerCAmelCase_						=      {}
            for i, token in enumerate(_UpperCAmelCase):
                  lowerCAmelCase_						=      i
            lowerCAmelCase_						=      WordpieceTokenizer(vocab=_UpperCAmelCase					,					unk_token='''[UNK]''')

            self.assertListEqual(tokenizer.tokenize('''''')					,					[])

            self.assertListEqual(tokenizer.tokenize('''unwanted running''')					,					['''un''', '''##want''', '''##ed''', '''runn''', '''##ing'''])

            self.assertListEqual(tokenizer.tokenize('''unwantedX running''')					,					['''[UNK]''', '''runn''', '''##ing'''])







      def lowercase__		( self):
            self.assertTrue(_is_whitespace(''' '''))
            self.assertTrue(_is_whitespace('''\t'''))
            self.assertTrue(_is_whitespace('''\r'''))
            self.assertTrue(_is_whitespace('''\n'''))
            self.assertTrue(_is_whitespace('''\u00A0'''))

            self.assertFalse(_is_whitespace('''A'''))
            self.assertFalse(_is_whitespace('''-'''))







      def lowercase__		( self):
            self.assertTrue(_is_control('''\u0005'''))

            self.assertFalse(_is_control('''A'''))
            self.assertFalse(_is_control(''' '''))
            self.assertFalse(_is_control('''\t'''))
            self.assertFalse(_is_control('''\r'''))







      def lowercase__		( self):
            self.assertTrue(_is_punctuation('''-'''))
            self.assertTrue(_is_punctuation('''$'''))
            self.assertTrue(_is_punctuation('''`'''))
            self.assertTrue(_is_punctuation('''.'''))

            self.assertFalse(_is_punctuation('''A'''))
            self.assertFalse(_is_punctuation(''' '''))







      def lowercase__		( self):
            lowerCAmelCase_						=      self.get_tokenizer()
            lowerCAmelCase_						=      self.get_rust_tokenizer()

            # Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
            self.assertListEqual([tokenizer.tokenize(_UpperCAmelCase) for t in ['''Test''', '''\xad''', '''test''']]					,					[['''[UNK]'''], [], ['''[UNK]''']])

            self.assertListEqual(
                [rust_tokenizer.tokenize(_UpperCAmelCase) for t in ['''Test''', '''\xad''', '''test''']]					,					[['''[UNK]'''], [], ['''[UNK]''']])







      @slow
      def lowercase__		( self):
            lowerCAmelCase_						=      self.tokenizer_class.from_pretrained('''google/electra-base-discriminator''')

            lowerCAmelCase_						=      tokenizer.encode('''sequence builders'''					,					add_special_tokens=_UpperCAmelCase)
            lowerCAmelCase_						=      tokenizer.encode('''multi-sequence build'''					,					add_special_tokens=_UpperCAmelCase)

            lowerCAmelCase_						=      tokenizer.build_inputs_with_special_tokens(_UpperCAmelCase)
            lowerCAmelCase_						=      tokenizer.build_inputs_with_special_tokens(_UpperCAmelCase					,					_UpperCAmelCase)

            assert encoded_sentence == [101] + text + [102]
            assert encoded_pair == [101] + text + [102] + text_a + [102]







      def lowercase__		( self):
            for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
                  with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'):
                        lowerCAmelCase_						=      self.rust_tokenizer_class.from_pretrained(_UpperCAmelCase					,					**_UpperCAmelCase)

                        lowerCAmelCase_						=      f'A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'
                        lowerCAmelCase_						=      tokenizer_r.encode_plus(
                            _UpperCAmelCase					,					return_attention_mask=_UpperCAmelCase					,					return_token_type_ids=_UpperCAmelCase					,					return_offsets_mapping=_UpperCAmelCase					,					add_special_tokens=_UpperCAmelCase					,					)

                        lowerCAmelCase_						=      tokenizer_r.do_lower_case if hasattr(_UpperCAmelCase					,					'''do_lower_case''') else False
                        lowerCAmelCase_						=      (
                            [
                                ((0, 0), tokenizer_r.cls_token),
                                ((0, 1), '''A'''),
                                ((1, 2), ''','''),
                                ((3, 5), '''na'''),
                                ((5, 6), '''##ï'''),
                                ((6, 8), '''##ve'''),
                                ((9, 15), tokenizer_r.mask_token),
                                ((16, 21), '''Allen'''),
                                ((21, 23), '''##NL'''),
                                ((23, 24), '''##P'''),
                                ((25, 33), '''sentence'''),
                                ((33, 34), '''.'''),
                                ((0, 0), tokenizer_r.sep_token),
                            ]
                            if not do_lower_case
                            else [
                                ((0, 0), tokenizer_r.cls_token),
                                ((0, 1), '''a'''),
                                ((1, 2), ''','''),
                                ((3, 8), '''naive'''),
                                ((9, 15), tokenizer_r.mask_token),
                                ((16, 21), '''allen'''),
                                ((21, 23), '''##nl'''),
                                ((23, 24), '''##p'''),
                                ((25, 33), '''sentence'''),
                                ((33, 34), '''.'''),
                                ((0, 0), tokenizer_r.sep_token),
                            ]
                        )

                        self.assertEqual(
                            [e[1] for e in expected_results]					,					tokenizer_r.convert_ids_to_tokens(tokens['''input_ids''']))
                        self.assertEqual([e[0] for e in expected_results]					,					tokens['''offset_mapping'''])







      def lowercase__		( self):
            lowerCAmelCase_						=      ['''的''', '''人''', '''有''']
            lowerCAmelCase_						=      ''''''.join(_UpperCAmelCase)
            for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
                  with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'):
                        lowerCAmelCase_						=      True
                        lowerCAmelCase_						=      self.tokenizer_class.from_pretrained(_UpperCAmelCase					,					**_UpperCAmelCase)
                        lowerCAmelCase_						=      self.rust_tokenizer_class.from_pretrained(_UpperCAmelCase					,					**_UpperCAmelCase)

                        lowerCAmelCase_						=      tokenizer_p.encode(_UpperCAmelCase					,					add_special_tokens=_UpperCAmelCase)
                        lowerCAmelCase_						=      tokenizer_r.encode(_UpperCAmelCase					,					add_special_tokens=_UpperCAmelCase)

                        lowerCAmelCase_						=      tokenizer_r.convert_ids_to_tokens(_UpperCAmelCase)
                        lowerCAmelCase_						=      tokenizer_p.convert_ids_to_tokens(_UpperCAmelCase)

                        # it is expected that each Chinese character is not preceded by "##"
                        self.assertListEqual(_UpperCAmelCase					,					_UpperCAmelCase)
                        self.assertListEqual(_UpperCAmelCase					,					_UpperCAmelCase)

                        lowerCAmelCase_						=      False
                        lowerCAmelCase_						=      self.rust_tokenizer_class.from_pretrained(_UpperCAmelCase					,					**_UpperCAmelCase)
                        lowerCAmelCase_						=      self.tokenizer_class.from_pretrained(_UpperCAmelCase					,					**_UpperCAmelCase)

                        lowerCAmelCase_						=      tokenizer_r.encode(_UpperCAmelCase					,					add_special_tokens=_UpperCAmelCase)
                        lowerCAmelCase_						=      tokenizer_p.encode(_UpperCAmelCase					,					add_special_tokens=_UpperCAmelCase)

                        lowerCAmelCase_						=      tokenizer_r.convert_ids_to_tokens(_UpperCAmelCase)
                        lowerCAmelCase_						=      tokenizer_p.convert_ids_to_tokens(_UpperCAmelCase)

                        # it is expected that only the first Chinese character is not preceded by "##".
                        lowerCAmelCase_						=      [
                            f'##{token}' if idx != 0 else token for idx, token in enumerate(_UpperCAmelCase)
                        ]
                        self.assertListEqual(_UpperCAmelCase					,					_UpperCAmelCase)
                        self.assertListEqual(_UpperCAmelCase					,					_UpperCAmelCase)





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 			UpperCamelCase_				:




      '''simple docstring'''







      def __init__( self					,					_UpperCAmelCase					,					_UpperCAmelCase=13					,					_UpperCAmelCase=32					,					_UpperCAmelCase=2					,					_UpperCAmelCase=3					,					_UpperCAmelCase=16					,					_UpperCAmelCase=[1, 2, 1]					,					_UpperCAmelCase=[2, 2, 4]					,					_UpperCAmelCase=2					,					_UpperCAmelCase=2.0					,					_UpperCAmelCase=True					,					_UpperCAmelCase=0.0					,					_UpperCAmelCase=0.0					,					_UpperCAmelCase=0.1					,					_UpperCAmelCase="gelu"					,					_UpperCAmelCase=False					,					_UpperCAmelCase=True					,					_UpperCAmelCase=0.02					,					_UpperCAmelCase=1E-5					,					_UpperCAmelCase=True					,					_UpperCAmelCase=None					,					_UpperCAmelCase=True					,					_UpperCAmelCase=10					,					_UpperCAmelCase=8					,					_UpperCAmelCase=["stage1", "stage2"]					,					_UpperCAmelCase=[1, 2]					,					):
            lowerCAmelCase_						=      parent
            lowerCAmelCase_						=      batch_size
            lowerCAmelCase_						=      image_size
            lowerCAmelCase_						=      patch_size
            lowerCAmelCase_						=      num_channels
            lowerCAmelCase_						=      embed_dim
            lowerCAmelCase_						=      depths
            lowerCAmelCase_						=      num_heads
            lowerCAmelCase_						=      window_size
            lowerCAmelCase_						=      mlp_ratio
            lowerCAmelCase_						=      qkv_bias
            lowerCAmelCase_						=      hidden_dropout_prob
            lowerCAmelCase_						=      attention_probs_dropout_prob
            lowerCAmelCase_						=      drop_path_rate
            lowerCAmelCase_						=      hidden_act
            lowerCAmelCase_						=      use_absolute_embeddings
            lowerCAmelCase_						=      patch_norm
            lowerCAmelCase_						=      layer_norm_eps
            lowerCAmelCase_						=      initializer_range
            lowerCAmelCase_						=      is_training
            lowerCAmelCase_						=      scope
            lowerCAmelCase_						=      use_labels
            lowerCAmelCase_						=      type_sequence_label_size
            lowerCAmelCase_						=      encoder_stride
            lowerCAmelCase_						=      out_features
            lowerCAmelCase_						=      out_indices







      def lowercase__		( self):
            lowerCAmelCase_						=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

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

            lowerCAmelCase_						=      self.get_config()

            return config, pixel_values, labels







      def lowercase__		( 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 lowercase__		( self					,					_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase):
            lowerCAmelCase_						=      SwinModel(config=_UpperCAmelCase)
            model.to(_UpperCAmelCase)
            model.eval()
            lowerCAmelCase_						=      model(_UpperCAmelCase)

            lowerCAmelCase_						=      ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths) - 1))
            lowerCAmelCase_						=      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 lowercase__		( self					,					_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase):
            lowerCAmelCase_						=      SwinBackbone(config=_UpperCAmelCase)
            model.to(_UpperCAmelCase)
            model.eval()
            lowerCAmelCase_						=      model(_UpperCAmelCase)

            # 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], 16, 16])

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

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

            # 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 lowercase__		( self					,					_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase):
            lowerCAmelCase_						=      SwinForMaskedImageModeling(config=_UpperCAmelCase)
            model.to(_UpperCAmelCase)
            model.eval()
            lowerCAmelCase_						=      model(_UpperCAmelCase)
            self.parent.assertEqual(
                result.logits.shape					,					(self.batch_size, self.num_channels, self.image_size, self.image_size))

            # test greyscale images
            lowerCAmelCase_						=      1
            lowerCAmelCase_						=      SwinForMaskedImageModeling(_UpperCAmelCase)
            model.to(_UpperCAmelCase)
            model.eval()

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







      def lowercase__		( self					,					_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase):
            lowerCAmelCase_						=      self.type_sequence_label_size
            lowerCAmelCase_						=      SwinForImageClassification(_UpperCAmelCase)
            model.to(_UpperCAmelCase)
            model.eval()
            lowerCAmelCase_						=      model(_UpperCAmelCase					,					labels=_UpperCAmelCase)
            self.parent.assertEqual(result.logits.shape					,					(self.batch_size, self.type_sequence_label_size))

            # test greyscale images
            lowerCAmelCase_						=      1
            lowerCAmelCase_						=      SwinForImageClassification(_UpperCAmelCase)
            model.to(_UpperCAmelCase)
            model.eval()

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







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


@require_torch
class 			UpperCamelCase_				(  A					,       A					,       unittest.TestCase     ):




      '''simple docstring'''







      a		:str						 =      (
          (
              SwinModel,
              SwinBackbone,
              SwinForImageClassification,
              SwinForMaskedImageModeling,
          )
          if is_torch_available()
          else ()
      )
      a		:Optional[Any]						 =      (
          {'feature-extraction': SwinModel, 'image-classification': SwinForImageClassification}
          if is_torch_available()
          else {}
      )
      a		:Optional[int]						 =      True

      a		:Dict						 =      False
      a		:Dict						 =      False
      a		:int						 =      False







      def lowercase__		( self):
            lowerCAmelCase_						=      SwinModelTester(self)
            lowerCAmelCase_						=      ConfigTester(self					,					config_class=_UpperCAmelCase					,					embed_dim=37)







      def lowercase__		( 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 lowercase__		( self):
            return







      def lowercase__		( self):
            lowerCAmelCase_						=      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*_UpperCAmelCase)







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







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







      def lowercase__		( self):
            lowerCAmelCase_						=      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_backbone(*_UpperCAmelCase)







      def lowercase__		( self):
            lowerCAmelCase_						=      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_masked_image_modeling(*_UpperCAmelCase)







      def lowercase__		( self):
            lowerCAmelCase_						=      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_image_classification(*_UpperCAmelCase)







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







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







      def lowercase__		( self):
            lowerCAmelCase_			,		lowerCAmelCase_						=      self.model_tester.prepare_config_and_inputs_for_common()

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







      def lowercase__		( self):
            lowerCAmelCase_			,		lowerCAmelCase_						=      self.model_tester.prepare_config_and_inputs_for_common()

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

                  lowerCAmelCase_						=      ['''pixel_values''']
                  self.assertListEqual(arg_names[:1]					,					_UpperCAmelCase)







      def lowercase__		( self):
            lowerCAmelCase_			,		lowerCAmelCase_						=      self.model_tester.prepare_config_and_inputs_for_common()
            lowerCAmelCase_						=      True

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

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

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

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

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

                  lowerCAmelCase_						=      outputs.attentions

                  self.assertEqual(len(_UpperCAmelCase)					,					_UpperCAmelCase)

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







      def lowercase__		( self					,					_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase):
            lowerCAmelCase_						=      model_class(_UpperCAmelCase)
            model.to(_UpperCAmelCase)
            model.eval()

            with torch.no_grad():
                  lowerCAmelCase_						=      model(**self._prepare_for_class(_UpperCAmelCase					,					_UpperCAmelCase))

            lowerCAmelCase_						=      outputs.hidden_states

            lowerCAmelCase_						=      getattr(
                self.model_tester					,					'''expected_num_hidden_layers'''					,					len(self.model_tester.depths) + 1)
            self.assertEqual(len(_UpperCAmelCase)					,					_UpperCAmelCase)

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

            lowerCAmelCase_						=      (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":
                  lowerCAmelCase_						=      outputs.reshaped_hidden_states
                  self.assertEqual(len(_UpperCAmelCase)					,					_UpperCAmelCase)

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







      def lowercase__		( self):
            lowerCAmelCase_			,		lowerCAmelCase_						=      self.model_tester.prepare_config_and_inputs_for_common()

            lowerCAmelCase_						=      (
                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:
                  lowerCAmelCase_						=      True
                  self.check_hidden_states_output(_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase)

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

                  self.check_hidden_states_output(_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase)







      def lowercase__		( self):
            lowerCAmelCase_			,		lowerCAmelCase_						=      self.model_tester.prepare_config_and_inputs_for_common()
            lowerCAmelCase_						=      3

            lowerCAmelCase_						=      (
                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)
            )
            lowerCAmelCase_						=      (
                config.patch_size
                if isinstance(config.patch_size					,					collections.abc.Iterable)
                else (config.patch_size, config.patch_size)
            )

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

            for model_class in self.all_model_classes:
                  lowerCAmelCase_						=      True
                  self.check_hidden_states_output(_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase					,					(padded_height, padded_width))

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







      @slow
      def lowercase__		( self):
            for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                  lowerCAmelCase_						=      SwinModel.from_pretrained(_UpperCAmelCase)
                  self.assertIsNotNone(_UpperCAmelCase)







      def lowercase__		( self):
            lowerCAmelCase_			,		lowerCAmelCase_						=      self.model_tester.prepare_config_and_inputs_for_common()

            lowerCAmelCase_						=      _config_zero_init(_UpperCAmelCase)
            for model_class in self.all_model_classes:
                  lowerCAmelCase_						=      model_class(config=_UpperCAmelCase)
                  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 			UpperCamelCase_				(  unittest.TestCase     ):




      '''simple docstring'''







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







      @slow
      def lowercase__		( self):
            lowerCAmelCase_						=      SwinForImageClassification.from_pretrained('''microsoft/swin-tiny-patch4-window7-224''').to(_UpperCAmelCase)
            lowerCAmelCase_						=      self.default_image_processor

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

            # forward pass
            with torch.no_grad():
                  lowerCAmelCase_						=      model(**_UpperCAmelCase)

            # verify the logits
            lowerCAmelCase_						=      torch.Size((1, 1_000))
            self.assertEqual(outputs.logits.shape					,					_UpperCAmelCase)
            lowerCAmelCase_						=      torch.tensor([-0.0948, -0.6454, -0.0921]).to(_UpperCAmelCase)
            self.assertTrue(torch.allclose(outputs.logits[0, :3]					,					_UpperCAmelCase					,					atol=1E-4))


@require_torch
class 			UpperCamelCase_				(  unittest.TestCase					,       A     ):




      '''simple docstring'''







      a		:Optional[Any]						 =      (SwinBackbone,) if is_torch_available() else ()
      a		:List[str]						 =      SwinConfig







      def lowercase__		( self):
            lowerCAmelCase_						=      SwinModelTester(self)



