

"""simple docstring"""



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 (
    SEWConfig,
    SEWForCTC,
    SEWModel,
    WavaVecaCTCTokenizer,
    WavaVecaFeatureExtractor,
    WavaVecaProcessor,
    logging,
)


logging.set_verbosity_info()
SCREAMING_SNAKE_CASE_					:	Tuple							  =						logging.get_logger(__name__)

SCREAMING_SNAKE_CASE_					:	Tuple							  =						{
    'post_extract_proj': 'feature_projection',
    'encoder.pos_conv.0': 'encoder.pos_conv_embed.conv',
    'self_attn.k_proj': 'encoder.layers.*.attention.k_proj',
    'self_attn.v_proj': 'encoder.layers.*.attention.v_proj',
    'self_attn.q_proj': 'encoder.layers.*.attention.q_proj',
    'self_attn.out_proj': 'encoder.layers.*.attention.out_proj',
    'self_attn_layer_norm': 'encoder.layers.*.layer_norm',
    'fc1': 'encoder.layers.*.feed_forward.intermediate_dense',
    'fc2': 'encoder.layers.*.feed_forward.output_dense',
    'final_layer_norm': 'encoder.layers.*.final_layer_norm',
    '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  _snake_case     (    UpperCAmelCase_  :					Tuple					,   UpperCAmelCase_  :					Optional[int]					,   UpperCAmelCase_  :					int					,   UpperCAmelCase_  :					Any					,   UpperCAmelCase_  :					int			):
     for attribute in key.split("""."""			):
          A__										=  getattr(UpperCAmelCase_					,   UpperCAmelCase_			)

     if weight_type is not None:
          A__										=  getattr(UpperCAmelCase_					,   UpperCAmelCase_			).shape
     else:
          A__										=  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":
          A__										=  value
     elif weight_type == "weight_g":
          A__										=  value
     elif weight_type == "weight_v":
          A__										=  value
     elif weight_type == "bias":
          A__										=  value
     else:
          A__										=  value

     logger.info(F"""{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}."""			)





def  _snake_case     (    UpperCAmelCase_  :					Tuple					,   UpperCAmelCase_  :					int					,   UpperCAmelCase_  :					Dict			):
     A__										=  []
     A__										=  fairseq_model.state_dict()

     A__										=  hf_model.sew.feature_extractor if is_finetuned else hf_model.feature_extractor

     for name, value in fairseq_dict.items():
          A__										=  False
          if "conv_layers" in name:
               load_conv_layer(
                   UpperCAmelCase_					,   UpperCAmelCase_					,   UpperCAmelCase_					,   UpperCAmelCase_					,   hf_model.config.feat_extract_norm == """group"""					,   )
               A__										=  True
          else:
               for key, mapped_key in MAPPING.items():
                    A__										=  """sew.""" + 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]:
                         A__										=  True
                         if "*" in mapped_key:
                              A__										=  name.split(UpperCAmelCase_			)[0].split("""."""			)[-2]
                              A__										=  mapped_key.replace("""*"""					,   UpperCAmelCase_			)
                         if "weight_g" in name:
                              A__										=  """weight_g"""
                         elif "weight_v" in name:
                              A__										=  """weight_v"""
                         elif "weight" in name:
                              A__										=  """weight"""
                         elif "bias" in name:
                              A__										=  """bias"""
                         else:
                              A__										=  None
                         set_recursively(UpperCAmelCase_					,   UpperCAmelCase_					,   UpperCAmelCase_					,   UpperCAmelCase_					,   UpperCAmelCase_			)
                    continue
          if not is_used:
               unused_weights.append(UpperCAmelCase_			)

     logger.warning(F"""Unused weights: {unused_weights}"""			)





def  _snake_case     (    UpperCAmelCase_  :					Any					,   UpperCAmelCase_  :					Optional[Any]					,   UpperCAmelCase_  :					Optional[Any]					,   UpperCAmelCase_  :					List[str]					,   UpperCAmelCase_  :					Union[str, Any]			):
     A__										=  full_name.split("""conv_layers."""			)[-1]
     A__										=  name.split("""."""			)
     A__										=  int(items[0]			)
     A__										=  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."""
               )
               A__										=  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."""
               )
               A__										=  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."
               )
               A__										=  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."""
               )
               A__										=  value
               logger.info(F"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."""			)
     else:
          unused_weights.append(UpperCAmelCase_			)





def  _snake_case     (    UpperCAmelCase_  :					Union[str, Any]					,   UpperCAmelCase_  :					Any			):
     A__										=  SEWConfig()
     if is_finetuned:
          A__										=  model.wav_encoder.wav_model.cfg
     else:
          A__										=  model.cfg

     A__										=  fs_config.conv_bias
     A__										=  eval(fs_config.conv_feature_layers			)
     A__										=  [x[0] for x in conv_layers]
     A__										=  [x[1] for x in conv_layers]
     A__										=  [x[2] for x in conv_layers]
     A__										=  """gelu"""
     A__										=  """layer""" if fs_config.extractor_mode == """layer_norm""" else """group"""
     A__										=  0.0
     A__										=  fs_config.activation_fn.name
     A__										=  fs_config.encoder_embed_dim
     A__										=  0.02
     A__										=  fs_config.encoder_ffn_embed_dim
     A__										=  1e-5
     A__										=  fs_config.encoder_layerdrop
     A__										=  fs_config.encoder_attention_heads
     A__										=  fs_config.conv_pos_groups
     A__										=  fs_config.conv_pos
     A__										=  len(UpperCAmelCase_			)
     A__										=  fs_config.encoder_layers
     A__										=  fs_config.squeeze_factor

     # take care of any params that are overridden by the Wav2VecCtc model
     if is_finetuned:
          A__										=  model.cfg
          A__										=  fs_config.final_dropout
          A__										=  fs_config.layerdrop
     A__										=  fs_config.activation_dropout
     A__										=  fs_config.mask_prob > 0 or fs_config.mask_channel_prob > 0
     A__										=  fs_config.attention_dropout
     A__										=  fs_config.dropout_input
     A__										=  fs_config.dropout
     A__										=  fs_config.mask_channel_length
     A__										=  fs_config.mask_channel_prob
     A__										=  fs_config.mask_length
     A__										=  fs_config.mask_prob

     A__										=  """Wav2Vec2FeatureExtractor"""
     A__										=  """Wav2Vec2CTCTokenizer"""

     return config





@torch.no_grad()
def  _snake_case     (    UpperCAmelCase_  :					Dict					,   UpperCAmelCase_  :					Optional[int]					,   UpperCAmelCase_  :					Any=None					,   UpperCAmelCase_  :					Optional[int]=None					,   UpperCAmelCase_  :					List[str]=True			):

     if is_finetuned:
          A__			,				A__			,				A__										=  fairseq.checkpoint_utils.load_model_ensemble_and_task(
              [checkpoint_path]					,   arg_overrides={"""data""": """/""".join(dict_path.split("""/"""			)[:-1]			)}			)
     else:
          A__			,				A__			,				A__										=  fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path]			)

     if config_path is not None:
          A__										=  SEWConfig.from_pretrained(UpperCAmelCase_			)
     else:
          A__										=  convert_config(model[0]					,   UpperCAmelCase_			)
     A__										=  model[0].eval()

     A__										=  True if config.feat_extract_norm == """layer""" else False
     A__										=  WavaVecaFeatureExtractor(
         feature_size=1					,   sampling_rate=1_6000					,   padding_value=0					,   do_normalize=UpperCAmelCase_					,   return_attention_mask=UpperCAmelCase_					,   )

     if is_finetuned:
          if dict_path:
               A__										=  Dictionary.load(UpperCAmelCase_			)

               # important change bos & pad token id since CTC symbol is <pad> and
               # not <s> as in fairseq
               A__										=  target_dict.pad_index
               A__										=  target_dict.bos_index
               A__										=  target_dict.pad_index
               A__										=  target_dict.bos_index
               A__										=  target_dict.eos_index
               A__										=  len(target_dict.symbols			)
               A__										=  os.path.join(UpperCAmelCase_					,   """vocab.json"""			)
               if not os.path.isdir(UpperCAmelCase_			):
                    logger.error("""--pytorch_dump_folder_path ({}) should be a directory""".format(UpperCAmelCase_			)			)
                    return
               os.makedirs(UpperCAmelCase_					,   exist_ok=UpperCAmelCase_			)
               with open(UpperCAmelCase_					,   """w"""					,   encoding="""utf-8"""			) as vocab_handle:
                    json.dump(target_dict.indices					,   UpperCAmelCase_			)
               A__										=  WavaVecaCTCTokenizer(
                   UpperCAmelCase_					,   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=UpperCAmelCase_					,   )
               A__										=  WavaVecaProcessor(feature_extractor=UpperCAmelCase_					,   tokenizer=UpperCAmelCase_			)
               processor.save_pretrained(UpperCAmelCase_			)

          A__										=  SEWForCTC(UpperCAmelCase_			)
     else:
          A__										=  SEWModel(UpperCAmelCase_			)
          feature_extractor.save_pretrained(UpperCAmelCase_			)

     recursively_load_weights(UpperCAmelCase_					,   UpperCAmelCase_					,   UpperCAmelCase_			)

     hf_model.save_pretrained(UpperCAmelCase_			)


if __name__ == "__main__":
 SCREAMING_SNAKE_CASE_					:	List[str]							  =						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'
 )
 SCREAMING_SNAKE_CASE_					:	Any							  =						parser.parse_args()
 convert_sew_checkpoint(
     args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, args.is_finetuned
 )









"""simple docstring"""



import inspect
import unittest

from transformers import SegformerConfig, is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

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


if is_torch_available():
 import torch

 from transformers import (
     MODEL_MAPPING,
     SegformerForImageClassification,
     SegformerForSemanticSegmentation,
     SegformerModel,
 )
 from transformers.models.segformer.modeling_segformer import SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
 from PIL import Image

 from transformers import SegformerImageProcessor



class 					a						(       _lowerCamelCase				):



    """simple docstring"""



    def 				UpperCamelCase	(     self: Dict       ):






         """simple docstring"""


         A__										=  self.config_class(**self.inputs_dict       )
         self.parent.assertTrue(hasattr(UpperCamelCase    ,						"""hidden_sizes"""       )       )
         self.parent.assertTrue(hasattr(UpperCamelCase    ,						"""num_attention_heads"""       )       )
         self.parent.assertTrue(hasattr(UpperCamelCase    ,						"""num_encoder_blocks"""       )       )



class 					a						:



    """simple docstring"""



    def __init__(     self: str    ,						UpperCamelCase: Dict    ,						UpperCamelCase: int=13    ,						UpperCamelCase: Optional[int]=64    ,						UpperCamelCase: List[Any]=3    ,						UpperCamelCase: List[Any]=4    ,						UpperCamelCase: Optional[Any]=[2, 2, 2, 2]    ,						UpperCamelCase: Any=[8, 4, 2, 1]    ,						UpperCamelCase: Optional[int]=[16, 32, 64, 1_28]    ,						UpperCamelCase: str=[1, 4, 8, 16]    ,						UpperCamelCase: Dict=[1, 2, 4, 8]    ,						UpperCamelCase: Optional[Any]=True    ,						UpperCamelCase: Union[str, Any]=True    ,						UpperCamelCase: List[str]="gelu"    ,						UpperCamelCase: Tuple=0.1    ,						UpperCamelCase: Optional[int]=0.1    ,						UpperCamelCase: Tuple=0.02    ,						UpperCamelCase: int=3    ,						UpperCamelCase: str=None    ,						):






         """simple docstring"""


         A__										=  parent
         A__										=  batch_size
         A__										=  image_size
         A__										=  num_channels
         A__										=  num_encoder_blocks
         A__										=  sr_ratios
         A__										=  depths
         A__										=  hidden_sizes
         A__										=  downsampling_rates
         A__										=  num_attention_heads
         A__										=  is_training
         A__										=  use_labels
         A__										=  hidden_act
         A__										=  hidden_dropout_prob
         A__										=  attention_probs_dropout_prob
         A__										=  initializer_range
         A__										=  num_labels
         A__										=  scope

    def 				UpperCamelCase	(     self: Tuple       ):






         """simple docstring"""


         A__										=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

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

         A__										=  self.get_config()
         return config, pixel_values, labels

    def 				UpperCamelCase	(     self: Optional[int]       ):






         """simple docstring"""


         return SegformerConfig(
             image_size=self.image_size    ,						num_channels=self.num_channels    ,						num_encoder_blocks=self.num_encoder_blocks    ,						depths=self.depths    ,						hidden_sizes=self.hidden_sizes    ,						num_attention_heads=self.num_attention_heads    ,						hidden_act=self.hidden_act    ,						hidden_dropout_prob=self.hidden_dropout_prob    ,						attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,						initializer_range=self.initializer_range    ,						)

    def 				UpperCamelCase	(     self: Tuple    ,						UpperCamelCase: str    ,						UpperCamelCase: Optional[Any]    ,						UpperCamelCase: int       ):






         """simple docstring"""


         A__										=  SegformerModel(config=UpperCamelCase       )
         model.to(UpperCamelCase       )
         model.eval()
         A__										=  model(UpperCamelCase       )
         A__										=  A__										=  self.image_size // (self.downsampling_rates[-1] * 2)
         self.parent.assertEqual(
             result.last_hidden_state.shape    ,						(self.batch_size, self.hidden_sizes[-1], expected_height, expected_width)       )

    def 				UpperCamelCase	(     self: List[str]    ,						UpperCamelCase: Tuple    ,						UpperCamelCase: str    ,						UpperCamelCase: List[str]       ):






         """simple docstring"""


         A__										=  self.num_labels
         A__										=  SegformerForSemanticSegmentation(UpperCamelCase       )
         model.to(UpperCamelCase       )
         model.eval()
         A__										=  model(UpperCamelCase       )
         self.parent.assertEqual(
             result.logits.shape    ,						(self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4)       )
         A__										=  model(UpperCamelCase    ,						labels=UpperCamelCase       )
         self.parent.assertEqual(
             result.logits.shape    ,						(self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4)       )
         self.parent.assertGreater(result.loss    ,						0.0       )

    def 				UpperCamelCase	(     self: Optional[Any]    ,						UpperCamelCase: List[str]    ,						UpperCamelCase: str    ,						UpperCamelCase: Tuple       ):






         """simple docstring"""


         A__										=  1
         A__										=  SegformerForSemanticSegmentation(config=UpperCamelCase       )
         model.to(UpperCamelCase       )
         model.eval()
         A__										=  torch.randint(0    ,						1    ,						(self.batch_size, self.image_size, self.image_size)       ).to(UpperCamelCase       )
         A__										=  model(UpperCamelCase    ,						labels=UpperCamelCase       )
         self.parent.assertGreater(result.loss    ,						0.0       )





    def 				UpperCamelCase	(     self: Tuple       ):






         """simple docstring"""


         A__										=  self.prepare_config_and_inputs()
         A__			,				A__			,				A__										=  config_and_inputs
         A__										=  {"""pixel_values""": pixel_values}
         return config, inputs_dict



@require_torch
class 					a						(       _lowerCamelCase,	_lowerCamelCase,	unittest.TestCase				):



    """simple docstring"""



    UpperCAmelCase						 =					(
        (
            SegformerModel,
            SegformerForSemanticSegmentation,
            SegformerForImageClassification,
        )
        if is_torch_available()
        else ()
    )
    UpperCAmelCase						 =					(
        {
            "feature-extraction": SegformerModel,
            "image-classification": SegformerForImageClassification,
            "image-segmentation": SegformerForSemanticSegmentation,
        }
        if is_torch_available()
        else {}
    )

    UpperCAmelCase						 =					True
    UpperCAmelCase						 =					False
    UpperCAmelCase						 =					False
    UpperCAmelCase						 =					False

    def 				UpperCamelCase	(     self: Any       ):






         """simple docstring"""


         A__										=  SegformerModelTester(self       )
         A__										=  SegformerConfigTester(self    ,						config_class=UpperCamelCase       )

    def 				UpperCamelCase	(     self: Any       ):






         """simple docstring"""


         self.config_tester.run_common_tests()

    def 				UpperCamelCase	(     self: Dict       ):






         """simple docstring"""


         A__										=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*UpperCamelCase       )

    def 				UpperCamelCase	(     self: int       ):






         """simple docstring"""


         A__										=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_binary_image_segmentation(*UpperCamelCase       )

    def 				UpperCamelCase	(     self: Dict       ):






         """simple docstring"""


         A__										=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_segmentation(*UpperCamelCase       )

    @unittest.skip("""SegFormer does not use inputs_embeds"""       )
    def 				UpperCamelCase	(     self: List[str]       ):






         """simple docstring"""


         pass

    @unittest.skip("""SegFormer does not have get_input_embeddings method and get_output_embeddings methods"""       )
    def 				UpperCamelCase	(     self: str       ):






         """simple docstring"""


         pass

    def 				UpperCamelCase	(     self: Optional[Any]       ):






         """simple docstring"""


         A__			,				A__										=  self.model_tester.prepare_config_and_inputs_for_common()

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

              A__										=  ["""pixel_values"""]
              self.assertListEqual(arg_names[:1]    ,						UpperCamelCase       )

    def 				UpperCamelCase	(     self: List[Any]       ):






         """simple docstring"""


         A__			,				A__										=  self.model_tester.prepare_config_and_inputs_for_common()
         A__										=  True

         for model_class in self.all_model_classes:
              A__										=  True
              A__										=  False
              A__										=  True
              A__										=  model_class(UpperCamelCase       )
              model.to(UpperCamelCase       )
              model.eval()
              with torch.no_grad():
                   A__										=  model(**self._prepare_for_class(UpperCamelCase    ,						UpperCamelCase       )       )
              A__										=  outputs.attentions

              A__										=  sum(self.model_tester.depths       )
              self.assertEqual(len(UpperCamelCase       )    ,						UpperCamelCase       )

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

              self.assertEqual(len(UpperCamelCase       )    ,						UpperCamelCase       )

              # verify the first attentions (first block, first layer)
              A__										=  (self.model_tester.image_size // 4) ** 2
              A__										=  (self.model_tester.image_size // (4 * self.model_tester.sr_ratios[0])) ** 2
              self.assertListEqual(
                  list(attentions[0].shape[-3:]       )    ,						[self.model_tester.num_attention_heads[0], expected_seq_len, expected_reduced_seq_len]    ,						)

              # verify the last attentions (last block, last layer)
              A__										=  (self.model_tester.image_size // 32) ** 2
              A__										=  (self.model_tester.image_size // (32 * self.model_tester.sr_ratios[-1])) ** 2
              self.assertListEqual(
                  list(attentions[-1].shape[-3:]       )    ,						[self.model_tester.num_attention_heads[-1], expected_seq_len, expected_reduced_seq_len]    ,						)
              A__										=  len(UpperCamelCase       )

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

              self.assertEqual(out_len + 1    ,						len(UpperCamelCase       )       )

              A__										=  outputs.attentions

              self.assertEqual(len(UpperCamelCase       )    ,						UpperCamelCase       )
              # verify the first attentions (first block, first layer)
              A__										=  (self.model_tester.image_size // 4) ** 2
              A__										=  (self.model_tester.image_size // (4 * self.model_tester.sr_ratios[0])) ** 2
              self.assertListEqual(
                  list(self_attentions[0].shape[-3:]       )    ,						[self.model_tester.num_attention_heads[0], expected_seq_len, expected_reduced_seq_len]    ,						)

    def 				UpperCamelCase	(     self: Union[str, Any]       ):






         """simple docstring"""


         def check_hidden_states_output(UpperCamelCase: Dict    ,						UpperCamelCase: Tuple    ,						UpperCamelCase: Dict       ):
              A__										=  model_class(UpperCamelCase       )
              model.to(UpperCamelCase       )
              model.eval()

              with torch.no_grad():
                   A__										=  model(**self._prepare_for_class(UpperCamelCase    ,						UpperCamelCase       )       )

              A__										=  outputs.hidden_states

              A__										=  self.model_tester.num_encoder_blocks
              self.assertEqual(len(UpperCamelCase       )    ,						UpperCamelCase       )

              # verify the first hidden states (first block)
              self.assertListEqual(
                  list(hidden_states[0].shape[-3:]       )    ,						[
                      self.model_tester.hidden_sizes[0],
                      self.model_tester.image_size // 4,
                      self.model_tester.image_size // 4,
                  ]    ,						)

         A__			,				A__										=  self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
              A__										=  True
              check_hidden_states_output(UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase       )

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

              check_hidden_states_output(UpperCamelCase    ,						UpperCamelCase    ,						UpperCamelCase       )

    def 				UpperCamelCase	(     self: Union[str, Any]       ):






         """simple docstring"""


         if not self.model_tester.is_training:
              return

         A__			,				A__										=  self.model_tester.prepare_config_and_inputs_for_common()
         A__										=  True

         for model_class in self.all_model_classes:
              if model_class in get_values(UpperCamelCase       ):
                   continue

              A__										=  model_class(UpperCamelCase       )
              model.to(UpperCamelCase       )
              model.train()
              A__										=  self._prepare_for_class(UpperCamelCase    ,						UpperCamelCase    ,						return_labels=UpperCamelCase       )
              A__										=  model(**UpperCamelCase       ).loss
              loss.backward()

    @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""       )
    def 				UpperCamelCase	(     self: Optional[int]       ):






         """simple docstring"""


         pass





    @slow
    def 				UpperCamelCase	(     self: Optional[Any]       ):






         """simple docstring"""


         for model_name in SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              A__										=  SegformerModel.from_pretrained(UpperCamelCase       )
              self.assertIsNotNone(UpperCamelCase       )





def  _snake_case     (    ):
     A__										=  Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""			)
     return image



@require_torch
class 					a						(       unittest.TestCase				):



    """simple docstring"""



    @slow
    def 				UpperCamelCase	(     self: Any       ):






         """simple docstring"""


         A__										=  SegformerImageProcessor(
             image_scale=(5_12, 5_12)    ,						keep_ratio=UpperCamelCase    ,						align=UpperCamelCase    ,						do_random_crop=UpperCamelCase       )
         A__										=  SegformerForSemanticSegmentation.from_pretrained("""nvidia/segformer-b0-finetuned-ade-512-512"""       ).to(
             UpperCamelCase       )

         A__										=  prepare_img()
         A__										=  image_processor(images=UpperCamelCase    ,						return_tensors="""pt"""       )
         A__										=  encoded_inputs.pixel_values.to(UpperCamelCase       )

         with torch.no_grad():
              A__										=  model(UpperCamelCase       )

         A__										=  torch.Size((1, model.config.num_labels, 1_28, 1_28)       )
         self.assertEqual(outputs.logits.shape    ,						UpperCamelCase       )

         A__										=  torch.tensor(
             [
                 [[-4.6_310, -5.5_232, -6.2_356], [-5.1_921, -6.1_444, -6.5_996], [-5.4_424, -6.2_790, -6.7_574]],
                 [[-12.1_391, -13.3_122, -13.9_554], [-12.8_732, -13.9_352, -14.3_563], [-12.9_438, -13.8_226, -14.2_513]],
                 [[-12.5_134, -13.4_686, -14.4_915], [-12.8_669, -14.4_343, -14.7_758], [-13.2_523, -14.5_819, -15.0_694]],
             ]       ).to(UpperCamelCase       )
         self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]    ,						UpperCamelCase    ,						atol=1e-4       )       )

    @slow
    def 				UpperCamelCase	(     self: Optional[Any]       ):






         """simple docstring"""


         A__										=  SegformerImageProcessor(
             image_scale=(5_12, 5_12)    ,						keep_ratio=UpperCamelCase    ,						align=UpperCamelCase    ,						do_random_crop=UpperCamelCase       )
         A__										=  SegformerForSemanticSegmentation.from_pretrained(
             """nvidia/segformer-b1-finetuned-cityscapes-1024-1024"""       ).to(UpperCamelCase       )

         A__										=  prepare_img()
         A__										=  image_processor(images=UpperCamelCase    ,						return_tensors="""pt"""       )
         A__										=  encoded_inputs.pixel_values.to(UpperCamelCase       )

         with torch.no_grad():
              A__										=  model(UpperCamelCase       )

         A__										=  torch.Size((1, model.config.num_labels, 1_28, 1_28)       )
         self.assertEqual(outputs.logits.shape    ,						UpperCamelCase       )

         A__										=  torch.tensor(
             [
                 [[-13.5_748, -13.9_111, -12.6_500], [-14.3_500, -15.3_683, -14.2_328], [-14.7_532, -16.0_424, -15.6_087]],
                 [[-17.1_651, -15.8_725, -12.9_653], [-17.2_580, -17.3_718, -14.8_223], [-16.6_058, -16.8_783, -16.7_452]],
                 [[-3.6_456, -3.0_209, -1.4_203], [-3.0_797, -3.1_959, -2.0_000], [-1.8_757, -1.9_217, -1.6_997]],
             ]       ).to(UpperCamelCase       )
         self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]    ,						UpperCamelCase    ,						atol=1e-1       )       )





    @slow
    def 				UpperCamelCase	(     self: List[Any]       ):






         """simple docstring"""


         A__										=  SegformerImageProcessor(
             image_scale=(5_12, 5_12)    ,						keep_ratio=UpperCamelCase    ,						align=UpperCamelCase    ,						do_random_crop=UpperCamelCase       )
         A__										=  SegformerForSemanticSegmentation.from_pretrained("""nvidia/segformer-b0-finetuned-ade-512-512"""       ).to(
             UpperCamelCase       )

         A__										=  prepare_img()
         A__										=  image_processor(images=UpperCamelCase    ,						return_tensors="""pt"""       )
         A__										=  encoded_inputs.pixel_values.to(UpperCamelCase       )

         with torch.no_grad():
              A__										=  model(UpperCamelCase       )

         A__										=  outputs.logits.detach().cpu()

         A__										=  image_processor.post_process_semantic_segmentation(outputs=UpperCamelCase    ,						target_sizes=[(5_00, 3_00)]       )
         A__										=  torch.Size((5_00, 3_00)       )
         self.assertEqual(segmentation[0].shape    ,						UpperCamelCase       )

         A__										=  image_processor.post_process_semantic_segmentation(outputs=UpperCamelCase       )
         A__										=  torch.Size((1_28, 1_28)       )
         self.assertEqual(segmentation[0].shape    ,						UpperCamelCase       )






