code: 
  
  
  
  
  
  
  import argparse
  import json
  import os
  
  import fairseq
  import torch
  from fairseq.data import Dictionary
  
  # Register SEW's fairseq modules
  from sew_asapp import tasks  # noqa: F401
  
  from transformers import (
      SEWDConfig,
      SEWDForCTC,
      SEWDModel,
      WavaVecaCTCTokenizer,
      WavaVecaFeatureExtractor,
      WavaVecaProcessor,
      logging,
  )
  
  
  logging.set_verbosity_info()
  __snake_case							      =						logging.get_logger(__name__)
  
  __snake_case							      =						{
      """post_extract_proj""": """feature_projection""",
      """encoder.pos_conv.0""": """encoder.pos_conv_embed.conv""",
      """attention.self.query_proj""": """encoder.encoder.layer.*.attention.self.query_proj""",
      """attention.self.key_proj""": """encoder.encoder.layer.*.attention.self.key_proj""",
      """attention.self.value_proj""": """encoder.encoder.layer.*.attention.self.value_proj""",
      """attention.output.dense""": """encoder.encoder.layer.*.attention.output.dense""",
      """attention.output.LayerNorm""": """encoder.encoder.layer.*.attention.output.LayerNorm""",
      """intermediate.dense""": """encoder.encoder.layer.*.intermediate.dense""",
      """output.dense""": """encoder.encoder.layer.*.output.dense""",
      """output.LayerNorm""": """encoder.encoder.layer.*.output.LayerNorm""",
      """encoder.encoder.rel_embeddings""": """encoder.encoder.rel_embeddings""",
      """encoder.encoder.LayerNorm""": """encoder.encoder.LayerNorm""",
      """encoder.upsample.0""": """encoder.upsample.projection""",
      """encoder.layer_norm""": """encoder.layer_norm""",
      """w2v_model.layer_norm""": """layer_norm""",
      """w2v_encoder.proj""": """lm_head""",
      """mask_emb""": """masked_spec_embed""",
  }
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			str  ,						SCREAMING_SNAKE_CASE__						:			Dict  ,						SCREAMING_SNAKE_CASE__						:			Optional[int]  ,						SCREAMING_SNAKE_CASE__						:			Dict  ,						SCREAMING_SNAKE_CASE__						:			Optional[int] ):
      for attribute in key.split('''.''' ):
          UpperCamelCase :List[Any]										=     getattr(SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__ )
  
      if weight_type is not None:
          UpperCamelCase :Dict										=     getattr(SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__ ).shape
      else:
          UpperCamelCase :int										=     hf_pointer.shape
  
      assert hf_shape == value.shape, (
          F'''Shape of hf {key + "." + weight_type if weight_type is not None else ""} is {hf_shape}, but should be'''
          F''' {value.shape} for {full_name}'''
      )
  
      if weight_type == "weight":
          UpperCamelCase :Any										=     value
      elif weight_type == "weight_g":
          UpperCamelCase :List[Any]										=     value
      elif weight_type == "weight_v":
          UpperCamelCase :str										=     value
      elif weight_type == "bias":
          UpperCamelCase :List[str]										=     value
      else:
          UpperCamelCase :Tuple										=     value
  
      logger.info(F'''{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.''' )
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			Optional[Any]  ,						SCREAMING_SNAKE_CASE__						:			List[str]  ,						SCREAMING_SNAKE_CASE__						:			Tuple ):
      UpperCamelCase :List[Any]										=     []
      UpperCamelCase :Tuple										=     fairseq_model.state_dict()
  
      UpperCamelCase :Tuple										=     hf_model.sew_d.feature_extractor if is_finetuned else hf_model.feature_extractor
  
      for name, value in fairseq_dict.items():
          UpperCamelCase :List[Any]										=     False
          if "conv_layers" in name:
              load_conv_layer(
                  SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__  ,						hf_model.config.feat_extract_norm == '''group'''  ,						)
              UpperCamelCase :List[str]										=     True
          else:
              for key, mapped_key in MAPPING.items():
                  UpperCamelCase :Optional[int]										=     '''sew_d.''' + mapped_key if (is_finetuned and mapped_key != '''lm_head''') else mapped_key
  
                  if key in name or key.split('''w2v_model.''' )[-1] == name.split('''.''' )[0]:
                      UpperCamelCase :List[str]										=     True
                      if "*" in mapped_key:
                          UpperCamelCase :Optional[Any]										=     name.split(SCREAMING_SNAKE_CASE__ )[0].split('''.''' )[-2]
                          if not layer_index.isnumeric():
                              continue
                          UpperCamelCase :Optional[Any]										=     mapped_key.replace('''*'''  ,						SCREAMING_SNAKE_CASE__ )
                      if "weight_g" in name:
                          UpperCamelCase :int										=     '''weight_g'''
                      elif "weight_v" in name:
                          UpperCamelCase :Union[str, Any]										=     '''weight_v'''
                      elif "weight" in name:
                          UpperCamelCase :Dict										=     '''weight'''
                      elif "bias" in name:
                          UpperCamelCase :Any										=     '''bias'''
                      else:
                          UpperCamelCase :str										=     None
                      set_recursively(SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__ )
                  continue
          if not is_used:
              unused_weights.append(SCREAMING_SNAKE_CASE__ )
  
      logger.warning(F'''Unused weights: {unused_weights}''' )
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			str  ,						SCREAMING_SNAKE_CASE__						:			str  ,						SCREAMING_SNAKE_CASE__						:			str  ,						SCREAMING_SNAKE_CASE__						:			Tuple  ,						SCREAMING_SNAKE_CASE__						:			Any ):
      UpperCamelCase :Tuple										=     full_name.split('''conv_layers.''' )[-1]
      UpperCamelCase :Union[str, Any]										=     name.split('''.''' )
      UpperCamelCase :Dict										=     int(items[0] )
      UpperCamelCase :Any										=     int(items[1] )
  
      if type_id == 0:
          if "bias" in name:
              assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
                  F'''{full_name} has size {value.shape}, but'''
                  F''' {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found.'''
              )
              UpperCamelCase :Optional[int]										=     value
              logger.info(F'''Feat extract conv layer {layer_id} was initialized from {full_name}.''' )
          elif "weight" in name:
              assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
                  F'''{full_name} has size {value.shape}, but'''
                  F''' {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found.'''
              )
              UpperCamelCase :Any										=     value
              logger.info(F'''Feat extract conv layer {layer_id} was initialized from {full_name}.''' )
      elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
          if "bias" in name:
              assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
                  F'''{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was'''
                  " found."
              )
              UpperCamelCase :int										=     value
              logger.info(F'''Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.''' )
          elif "weight" in name:
              assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
                  F'''{full_name} has size {value.shape}, but'''
                  F''' {feature_extractor[layer_id].layer_norm.weight.data.shape} was found.'''
              )
              UpperCamelCase :Optional[Any]										=     value
              logger.info(F'''Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.''' )
      else:
          unused_weights.append(SCREAMING_SNAKE_CASE__ )
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			str  ,						SCREAMING_SNAKE_CASE__						:			Any ):
      UpperCamelCase :Any										=     SEWDConfig()
      if is_finetuned:
          UpperCamelCase :List[Any]										=     model.wav_encoder.wav_model.cfg
      else:
          UpperCamelCase :Dict										=     model.cfg
  
      UpperCamelCase :Any										=     fs_config.conv_bias
      UpperCamelCase :List[Any]										=     eval(fs_config.conv_feature_layers )
      UpperCamelCase :Optional[int]										=     [x[0] for x in conv_layers]
      UpperCamelCase :List[str]										=     [x[1] for x in conv_layers]
      UpperCamelCase :Optional[Any]										=     [x[2] for x in conv_layers]
      UpperCamelCase :Any										=     '''gelu'''
      UpperCamelCase :Tuple										=     '''layer''' if fs_config.extractor_mode == '''layer_norm''' else '''group'''
      UpperCamelCase :Optional[int]										=     0.0
      UpperCamelCase :Tuple										=     fs_config.activation_fn.name
      UpperCamelCase :Optional[Any]										=     fs_config.encoder_embed_dim
      UpperCamelCase :Optional[Any]										=     0.02
      UpperCamelCase :Optional[Any]										=     fs_config.encoder_ffn_embed_dim
      UpperCamelCase :Optional[Any]										=     1e-5
      UpperCamelCase :Optional[Any]										=     fs_config.encoder_layerdrop
      UpperCamelCase :Dict										=     fs_config.encoder_attention_heads
      UpperCamelCase :List[str]										=     fs_config.conv_pos_groups
      UpperCamelCase :Union[str, Any]										=     fs_config.conv_pos
      UpperCamelCase :Tuple										=     len(SCREAMING_SNAKE_CASE__ )
      UpperCamelCase :List[Any]										=     fs_config.encoder_layers
      UpperCamelCase :Optional[Any]										=     fs_config.squeeze_factor
      # DeBERTa-specific parameters:
      UpperCamelCase :List[str]										=     fs_config.max_position_embeddings
      UpperCamelCase :str										=     fs_config.position_buckets
      UpperCamelCase :int										=     fs_config.share_att_key
      UpperCamelCase :Dict										=     fs_config.relative_attention
      UpperCamelCase :List[Any]										=     fs_config.position_biased_input
      UpperCamelCase :Optional[Any]										=     tuple(fs_config.pos_att_type.split('''|''' ) )
      UpperCamelCase :str										=     fs_config.norm_rel_ebd
  
      # take care of any params that are overridden by the Wav2VecCtc model
      if is_finetuned:
          UpperCamelCase :Tuple										=     model.cfg
          UpperCamelCase :Tuple										=     fs_config.final_dropout
          UpperCamelCase :Any										=     fs_config.layerdrop
      UpperCamelCase :List[Any]										=     fs_config.activation_dropout
      UpperCamelCase :Any										=     fs_config.mask_prob > 0 or fs_config.mask_channel_prob > 0
      UpperCamelCase :Optional[Any]										=     fs_config.attention_dropout
      UpperCamelCase :Dict										=     fs_config.dropout_input
      UpperCamelCase :int										=     fs_config.dropout
      UpperCamelCase :int										=     fs_config.mask_channel_length
      UpperCamelCase :Dict										=     fs_config.mask_channel_prob
      UpperCamelCase :Union[str, Any]										=     fs_config.mask_length
      UpperCamelCase :List[str]										=     fs_config.mask_prob
  
      UpperCamelCase :int										=     '''Wav2Vec2FeatureExtractor'''
      UpperCamelCase :int										=     '''Wav2Vec2CTCTokenizer'''
  
      return config
  
  
  @torch.no_grad()
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			str  ,						SCREAMING_SNAKE_CASE__						:			Optional[int]  ,						SCREAMING_SNAKE_CASE__						:			Any=None  ,						SCREAMING_SNAKE_CASE__						:			List[str]=None  ,						SCREAMING_SNAKE_CASE__						:			Any=True ):
  
      if is_finetuned:
          UpperCamelCase							,     UpperCamelCase							,     UpperCamelCase :str										=     fairseq.checkpoint_utils.load_model_ensemble_and_task(
              [checkpoint_path]  ,						arg_overrides={'''data''': '''/'''.join(dict_path.split('''/''' )[:-1] )} )
      else:
          UpperCamelCase							,     UpperCamelCase							,     UpperCamelCase :Union[str, Any]										=     fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path] )
  
      if config_path is not None:
          UpperCamelCase :str										=     SEWDConfig.from_pretrained(SCREAMING_SNAKE_CASE__ )
      else:
          UpperCamelCase :Tuple										=     convert_config(model[0]  ,						SCREAMING_SNAKE_CASE__ )
      UpperCamelCase :str										=     model[0].eval()
  
      UpperCamelCase :Tuple										=     True if config.feat_extract_norm == '''layer''' else False
      UpperCamelCase :Dict										=     WavaVecaFeatureExtractor(
          feature_size=1  ,						sampling_rate=16000  ,						padding_value=0  ,						do_normalize=SCREAMING_SNAKE_CASE__  ,						return_attention_mask=SCREAMING_SNAKE_CASE__  ,						)
  
      if is_finetuned:
          if dict_path:
              UpperCamelCase :Tuple										=     Dictionary.load(SCREAMING_SNAKE_CASE__ )
  
              # important change bos & pad token id since CTC symbol is <pad> and
              # not <s> as in fairseq
              UpperCamelCase :int										=     target_dict.pad_index
              UpperCamelCase :Union[str, Any]										=     target_dict.bos_index
              UpperCamelCase :Dict										=     target_dict.pad_index
              UpperCamelCase :Optional[int]										=     target_dict.bos_index
              UpperCamelCase :Optional[Any]										=     target_dict.eos_index
              UpperCamelCase :List[str]										=     len(target_dict.symbols )
              UpperCamelCase :Dict										=     os.path.join(SCREAMING_SNAKE_CASE__  ,						'''vocab.json''' )
              if not os.path.isdir(SCREAMING_SNAKE_CASE__ ):
                  logger.error('''--pytorch_dump_folder_path ({}) should be a directory'''.format(SCREAMING_SNAKE_CASE__ ) )
                  return
              os.makedirs(SCREAMING_SNAKE_CASE__  ,						exist_ok=SCREAMING_SNAKE_CASE__ )
              with open(SCREAMING_SNAKE_CASE__  ,						'''w'''  ,						encoding='''utf-8''' ) as vocab_handle:
                  json.dump(target_dict.indices  ,						SCREAMING_SNAKE_CASE__ )
              UpperCamelCase :Dict										=     WavaVecaCTCTokenizer(
                  SCREAMING_SNAKE_CASE__  ,						unk_token=target_dict.unk_word  ,						pad_token=target_dict.pad_word  ,						bos_token=target_dict.bos_word  ,						eos_token=target_dict.eos_word  ,						word_delimiter_token='''|'''  ,						do_lower_case=SCREAMING_SNAKE_CASE__  ,						)
              UpperCamelCase :Optional[int]										=     WavaVecaProcessor(feature_extractor=SCREAMING_SNAKE_CASE__  ,						tokenizer=SCREAMING_SNAKE_CASE__ )
              processor.save_pretrained(SCREAMING_SNAKE_CASE__ )
  
          UpperCamelCase :Tuple										=     SEWDForCTC(SCREAMING_SNAKE_CASE__ )
      else:
          UpperCamelCase :List[str]										=     SEWDModel(SCREAMING_SNAKE_CASE__ )
          feature_extractor.save_pretrained(SCREAMING_SNAKE_CASE__ )
  
      recursively_load_weights(SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__ )
  
      hf_model.save_pretrained(SCREAMING_SNAKE_CASE__ )
  
  
  if __name__ == "__main__":
   __snake_case							      =						argparse.ArgumentParser()
   parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""")
   parser.add_argument("""--checkpoint_path""", default=None, type=str, help="""Path to fairseq checkpoint""")
   parser.add_argument("""--dict_path""", default=None, type=str, help="""Path to dict of fine-tuned model""")
   parser.add_argument("""--config_path""", default=None, type=str, help="""Path to hf config.json of model to convert""")
   parser.add_argument(
       """--is_finetuned""", action="""store_true""", help="""Whether the model to convert is a fine-tuned model or not"""
   )
   __snake_case							      =						parser.parse_args()
   convert_sew_checkpoint(
       args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, args.is_finetuned
   )
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  from __future__ import annotations
  
  import inspect
  import unittest
  
  import numpy as np
  
  from transformers import SwinConfig
  from transformers.testing_utils import require_tf, require_vision, slow, to_atuple
  from transformers.utils import cached_property, is_tf_available, is_vision_available
  
  from ...test_configuration_common import ConfigTester
  from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
  from ...test_pipeline_mixin import PipelineTesterMixin
  
  
  if is_tf_available():
   import tensorflow as tf
  
   from transformers.models.swin.modeling_tf_swin import (
       TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
       TFSwinForImageClassification,
       TFSwinForMaskedImageModeling,
       TFSwinModel,
   )
  
  
  if is_vision_available():
   from PIL import Image
  
   from transformers import AutoImageProcessor
  
  
  
  
  
  
  
  class     UpperCAmelCase_		:
  
  
  
        """simple docstring"""
        def __init__(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_=13					,       SCREAMING_SNAKE_CASE_=32					,       SCREAMING_SNAKE_CASE_=2					,       SCREAMING_SNAKE_CASE_=3					,       SCREAMING_SNAKE_CASE_=16					,       SCREAMING_SNAKE_CASE_=[1, 2, 1]					,       SCREAMING_SNAKE_CASE_=[2, 2, 4]					,       SCREAMING_SNAKE_CASE_=2					,       SCREAMING_SNAKE_CASE_=2.0					,       SCREAMING_SNAKE_CASE_=True					,       SCREAMING_SNAKE_CASE_=0.0					,       SCREAMING_SNAKE_CASE_=0.0					,       SCREAMING_SNAKE_CASE_=0.1					,       SCREAMING_SNAKE_CASE_="gelu"					,       SCREAMING_SNAKE_CASE_=False					,       SCREAMING_SNAKE_CASE_=True					,       SCREAMING_SNAKE_CASE_=0.02					,       SCREAMING_SNAKE_CASE_=1e-5					,       SCREAMING_SNAKE_CASE_=True					,       SCREAMING_SNAKE_CASE_=None					,       SCREAMING_SNAKE_CASE_=True					,       SCREAMING_SNAKE_CASE_=10					,       SCREAMING_SNAKE_CASE_=8					,       )       ->   None:
            UpperCamelCase :Optional[Any]										=     parent
            UpperCamelCase :Optional[Any]										=     batch_size
            UpperCamelCase :List[Any]										=     image_size
            UpperCamelCase :List[Any]										=     patch_size
            UpperCamelCase :List[Any]										=     num_channels
            UpperCamelCase :Optional[Any]										=     embed_dim
            UpperCamelCase :List[Any]										=     depths
            UpperCamelCase :List[Any]										=     num_heads
            UpperCamelCase :Tuple										=     window_size
            UpperCamelCase :Optional[int]										=     mlp_ratio
            UpperCamelCase :int										=     qkv_bias
            UpperCamelCase :str										=     hidden_dropout_prob
            UpperCamelCase :Dict										=     attention_probs_dropout_prob
            UpperCamelCase :Dict										=     drop_path_rate
            UpperCamelCase :Optional[Any]										=     hidden_act
            UpperCamelCase :int										=     use_absolute_embeddings
            UpperCamelCase :Any										=     patch_norm
            UpperCamelCase :str										=     layer_norm_eps
            UpperCamelCase :List[Any]										=     initializer_range
            UpperCamelCase :str										=     is_training
            UpperCamelCase :Union[str, Any]										=     scope
            UpperCamelCase :List[str]										=     use_labels
            UpperCamelCase :Union[str, Any]										=     type_sequence_label_size
            UpperCamelCase :int										=     encoder_stride
        def 					UpperCAmelCase		(       self				)       ->   Optional[int]:
            UpperCamelCase :Dict										=     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)
  
            UpperCamelCase :List[Any]										=     None
            if self.use_labels:
                UpperCamelCase :Tuple										=     ids_tensor([self.batch_size]					,       self.type_sequence_label_size				)
  
            UpperCamelCase :List[str]										=     self.get_config()
  
            return config, pixel_values, labels
        def 					UpperCAmelCase		(       self				)       ->   int:
            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					,       )
        def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)       ->   List[Any]:
            UpperCamelCase :int										=     TFSwinModel(config=SCREAMING_SNAKE_CASE_				)
            UpperCamelCase :Tuple										=     model(SCREAMING_SNAKE_CASE_				)
  
            UpperCamelCase :str										=     ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths				) - 1))
            UpperCamelCase :Union[str, Any]										=     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					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)       ->   Any:
            UpperCamelCase :int										=     TFSwinForMaskedImageModeling(config=SCREAMING_SNAKE_CASE_				)
            UpperCamelCase :List[str]										=     model(SCREAMING_SNAKE_CASE_				)
            self.parent.assertEqual(
                result.logits.shape					,       (self.batch_size, self.num_channels, self.image_size, self.image_size)				)
  
            # test greyscale images
            UpperCamelCase :Optional[int]										=     1
            UpperCamelCase :int										=     TFSwinForMaskedImageModeling(SCREAMING_SNAKE_CASE_				)
  
            UpperCamelCase :str										=     floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
            UpperCamelCase :str										=     model(SCREAMING_SNAKE_CASE_				)
            self.parent.assertEqual(result.logits.shape					,       (self.batch_size, 1, self.image_size, self.image_size)				)
        def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)       ->   List[str]:
            UpperCamelCase :Optional[Any]										=     self.type_sequence_label_size
            UpperCamelCase :Optional[int]										=     TFSwinForImageClassification(SCREAMING_SNAKE_CASE_				)
            UpperCamelCase :Tuple										=     model(SCREAMING_SNAKE_CASE_					,       labels=SCREAMING_SNAKE_CASE_				)
            self.parent.assertEqual(result.logits.shape					,       (self.batch_size, self.type_sequence_label_size)				)
  
            # test greyscale images
            UpperCamelCase :Union[str, Any]										=     1
            UpperCamelCase :Tuple										=     TFSwinForImageClassification(SCREAMING_SNAKE_CASE_				)
            UpperCamelCase :Any										=     floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
            UpperCamelCase :Tuple										=     model(SCREAMING_SNAKE_CASE_				)
            self.parent.assertEqual(result.logits.shape					,       (self.batch_size, self.type_sequence_label_size)				)
  
  
  
  
        def 					UpperCAmelCase		(       self				)       ->   int:
            UpperCamelCase :List[str]										=     self.prepare_config_and_inputs()
            UpperCamelCase							,     UpperCamelCase							,     UpperCamelCase :Optional[Any]										=     config_and_inputs
            UpperCamelCase :Any										=     {'''pixel_values''': pixel_values}
            return config, inputs_dict
  
  
  
  
  
  
  
  @require_tf
  class     UpperCAmelCase_		(      lowercase,			lowercase,			unittest.TestCase				):
  
  
  
        """simple docstring"""
        UpperCamelCase_       :      int     =(
            (
                TFSwinModel,
                TFSwinForImageClassification,
                TFSwinForMaskedImageModeling,
            )
            if is_tf_available()
            else ()
        )
        UpperCamelCase_       :      Any     =(
            {'feature-extraction': TFSwinModel, 'image-classification': TFSwinForImageClassification}
            if is_tf_available()
            else {}
        )
  
        UpperCamelCase_       :      Optional[int]     =False
        UpperCamelCase_       :      int     =False
        UpperCamelCase_       :      Optional[int]     =False
        UpperCamelCase_       :      Any     =False
        def 					UpperCAmelCase		(       self				)       ->   Tuple:
            UpperCamelCase :str										=     TFSwinModelTester(self				)
            UpperCamelCase :str										=     ConfigTester(self					,       config_class=SCREAMING_SNAKE_CASE_					,       embed_dim=37				)
        def 					UpperCAmelCase		(       self				)       ->   Dict:
            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				)       ->   Union[str, Any]:
            return
        def 					UpperCAmelCase		(       self				)       ->   Optional[Any]:
            UpperCamelCase :Any										=     self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_				)
        def 					UpperCAmelCase		(       self				)       ->   Optional[int]:
            UpperCamelCase :Optional[int]										=     self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_masked_image_modeling(*SCREAMING_SNAKE_CASE_				)
        def 					UpperCAmelCase		(       self				)       ->   Optional[Any]:
            UpperCamelCase :Any										=     self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE_				)
        @unittest.skip(reason='''Swin does not use inputs_embeds'''				)
        def 					UpperCAmelCase		(       self				)       ->   Union[str, Any]:
            pass
        def 					UpperCAmelCase		(       self				)       ->   Optional[int]:
            UpperCamelCase							,     UpperCamelCase :int										=     self.model_tester.prepare_config_and_inputs_for_common()
  
            for model_class in self.all_model_classes:
                UpperCamelCase :Optional[int]										=     model_class(SCREAMING_SNAKE_CASE_				)
                self.assertIsInstance(model.get_input_embeddings()					,       tf.keras.layers.Layer				)
                UpperCamelCase :Union[str, Any]										=     model.get_output_embeddings()
                self.assertTrue(x is None or isinstance(SCREAMING_SNAKE_CASE_					,       tf.keras.layers.Dense				)				)
        def 					UpperCAmelCase		(       self				)       ->   str:
            UpperCamelCase							,     UpperCamelCase :str										=     self.model_tester.prepare_config_and_inputs_for_common()
  
            for model_class in self.all_model_classes:
                UpperCamelCase :Union[str, Any]										=     model_class(SCREAMING_SNAKE_CASE_				)
                UpperCamelCase :Union[str, Any]										=     inspect.signature(model.call				)
                # signature.parameters is an OrderedDict => so arg_names order is deterministic
                UpperCamelCase :Dict										=     [*signature.parameters.keys()]
  
                UpperCamelCase :Tuple										=     ['''pixel_values''']
                self.assertListEqual(arg_names[:1]					,       SCREAMING_SNAKE_CASE_				)
        def 					UpperCAmelCase		(       self				)       ->   List[Any]:
            UpperCamelCase							,     UpperCamelCase :Optional[int]										=     self.model_tester.prepare_config_and_inputs_for_common()
            UpperCamelCase :str										=     True
  
            for model_class in self.all_model_classes:
                UpperCamelCase :List[Any]										=     True
                UpperCamelCase :Optional[Any]										=     False
                UpperCamelCase :List[str]										=     True
                UpperCamelCase :Optional[int]										=     model_class(SCREAMING_SNAKE_CASE_				)
                UpperCamelCase :Union[str, Any]										=     model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)				)
                UpperCamelCase :List[Any]										=     outputs.attentions
                UpperCamelCase :int										=     len(self.model_tester.depths				)
                self.assertEqual(len(SCREAMING_SNAKE_CASE_				)					,       SCREAMING_SNAKE_CASE_				)
  
                # check that output_attentions also work using config
                del inputs_dict["output_attentions"]
                UpperCamelCase :Optional[Any]										=     True
                UpperCamelCase :List[Any]										=     config.window_size**2
                UpperCamelCase :Dict										=     model_class(SCREAMING_SNAKE_CASE_				)
                UpperCamelCase :Dict										=     model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)				)
                UpperCamelCase :List[Any]										=     outputs.attentions
                self.assertEqual(len(SCREAMING_SNAKE_CASE_				)					,       SCREAMING_SNAKE_CASE_				)
  
                self.assertListEqual(
                    list(attentions[0].shape[-3:]				)					,       [self.model_tester.num_heads[0], window_size_squared, window_size_squared]					,       )
                UpperCamelCase :List[Any]										=     len(SCREAMING_SNAKE_CASE_				)
  
                # Check attention is always last and order is fine
                UpperCamelCase :int										=     True
                UpperCamelCase :List[str]										=     True
                UpperCamelCase :List[str]										=     model_class(SCREAMING_SNAKE_CASE_				)
                UpperCamelCase :Tuple										=     model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)				)
  
                if hasattr(self.model_tester					,       '''num_hidden_states_types'''				):
                    UpperCamelCase :Union[str, Any]										=     self.model_tester.num_hidden_states_types
                else:
                    # also another +1 for reshaped_hidden_states
                    UpperCamelCase :Optional[int]										=     2
                self.assertEqual(out_len + added_hidden_states					,       len(SCREAMING_SNAKE_CASE_				)				)
  
                UpperCamelCase :Optional[int]										=     outputs.attentions
  
                self.assertEqual(len(SCREAMING_SNAKE_CASE_				)					,       SCREAMING_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					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)       ->   Dict:
            UpperCamelCase :Optional[int]										=     model_class(SCREAMING_SNAKE_CASE_				)
            UpperCamelCase :Any										=     model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)				)
            UpperCamelCase :Union[str, Any]										=     outputs.hidden_states
  
            UpperCamelCase :Any										=     getattr(
                self.model_tester					,       '''expected_num_hidden_layers'''					,       len(self.model_tester.depths				) + 1				)
            self.assertEqual(len(SCREAMING_SNAKE_CASE_				)					,       SCREAMING_SNAKE_CASE_				)
  
            # Swin has a different seq_length
            UpperCamelCase :str										=     to_atuple(config.patch_size				)
  
            UpperCamelCase :Optional[int]										=     (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]					,       )
  
            UpperCamelCase :str										=     outputs.reshaped_hidden_states
            self.assertEqual(len(SCREAMING_SNAKE_CASE_				)					,       SCREAMING_SNAKE_CASE_				)
  
            UpperCamelCase							,     UpperCamelCase							,     UpperCamelCase							,     UpperCamelCase :Optional[int]										=     reshaped_hidden_states[0].shape
  
            UpperCamelCase :int										=     tf.reshape(reshaped_hidden_states[0]					,       (batch_size, num_channels, height * width)				)
            UpperCamelCase :Dict										=     tf.transpose(SCREAMING_SNAKE_CASE_					,       (0, 2, 1)				)
  
            self.assertListEqual(
                list(reshaped_hidden_states.shape[-2:]				)					,       [num_patches, self.model_tester.embed_dim]					,       )
        def 					UpperCAmelCase		(       self				)       ->   str:
            UpperCamelCase							,     UpperCamelCase :int										=     self.model_tester.prepare_config_and_inputs_for_common()
  
            UpperCamelCase :List[Any]										=     to_atuple(self.model_tester.image_size				)
  
            for model_class in self.all_model_classes:
                UpperCamelCase :List[Any]										=     True
                self.check_hidden_states_output(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)
  
                # check that output_hidden_states also work using config
                del inputs_dict["output_hidden_states"]
                UpperCamelCase :List[str]										=     True
  
                self.check_hidden_states_output(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)
        def 					UpperCAmelCase		(       self				)       ->   Optional[Any]:
            UpperCamelCase							,     UpperCamelCase :List[Any]										=     self.model_tester.prepare_config_and_inputs_for_common()
            UpperCamelCase :List[Any]										=     3
  
            UpperCamelCase :Any										=     to_atuple(self.model_tester.image_size				)
            UpperCamelCase :List[Any]										=     to_atuple(config.patch_size				)
  
            UpperCamelCase :Dict										=     image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
            UpperCamelCase :List[str]										=     image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])
  
            for model_class in self.all_model_classes:
                UpperCamelCase :List[Any]										=     True
                self.check_hidden_states_output(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       (padded_height, padded_width)				)
  
                # check that output_hidden_states also work using config
                del inputs_dict["output_hidden_states"]
                UpperCamelCase :str										=     True
                self.check_hidden_states_output(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       (padded_height, padded_width)				)
  
  
  
  
        @slow
        def 					UpperCAmelCase		(       self				)       ->   List[Any]:
            for model_name in TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                UpperCamelCase :Dict										=     TFSwinModel.from_pretrained(SCREAMING_SNAKE_CASE_				)
                self.assertIsNotNone(SCREAMING_SNAKE_CASE_				)
  
  
  
  
  
  
  
  @require_vision
  @require_tf
  class     UpperCAmelCase_		(      unittest.TestCase				):
  
  
  
        """simple docstring"""
        @cached_property
        def 					UpperCAmelCase		(       self				)       ->   Union[str, Any]:
            return (
                AutoImageProcessor.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''				)
                if is_vision_available()
                else None
            )
  
  
  
  
        @slow
        def 					UpperCAmelCase		(       self				)       ->   Optional[int]:
            UpperCamelCase :Tuple										=     TFSwinForImageClassification.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''				)
            UpperCamelCase :int										=     self.default_image_processor
  
            UpperCamelCase :Optional[int]										=     Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''				)
            UpperCamelCase :List[str]										=     image_processor(images=SCREAMING_SNAKE_CASE_					,       return_tensors='''tf'''				)
  
            # forward pass
            UpperCamelCase :Optional[Any]										=     model(SCREAMING_SNAKE_CASE_				)
  
            # verify the logits
            UpperCamelCase :Tuple										=     tf.TensorShape((1, 1000)				)
            self.assertEqual(outputs.logits.shape					,       SCREAMING_SNAKE_CASE_				)
            UpperCamelCase :List[Any]										=     tf.constant([-0.0948, -0.6454, -0.0921]				)
            self.assertTrue(np.allclose(outputs.logits[0, :3]					,       SCREAMING_SNAKE_CASE_					,       atol=1e-4				)				)
  
  
  
  
  
  