






'''simple docstring'''

from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import ResNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
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 import TFResNetForImageClassification, TFResNetModel
     from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
     from PIL import Image

     from transformers import AutoImageProcessor






class        a_		:

  def __init__(   self    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE=3    ,	_SCREAMING_SNAKE_CASE=32    ,	_SCREAMING_SNAKE_CASE=3    ,	_SCREAMING_SNAKE_CASE=10    ,	_SCREAMING_SNAKE_CASE=[10, 20, 30, 40]    ,	_SCREAMING_SNAKE_CASE=[1, 1, 2, 1]    ,	_SCREAMING_SNAKE_CASE=True    ,	_SCREAMING_SNAKE_CASE=True    ,	_SCREAMING_SNAKE_CASE="relu"    ,	_SCREAMING_SNAKE_CASE=3    ,	_SCREAMING_SNAKE_CASE=None    ,	)						->   Union[str, Any]:



        """simple docstring"""






        UpperCamelCase       						=      parent
        UpperCamelCase       						=      batch_size
        UpperCamelCase       						=      image_size
        UpperCamelCase       						=      num_channels
        UpperCamelCase       						=      embeddings_size
        UpperCamelCase       						=      hidden_sizes
        UpperCamelCase       						=      depths
        UpperCamelCase       						=      is_training
        UpperCamelCase       						=      use_labels
        UpperCamelCase       						=      hidden_act
        UpperCamelCase       						=      num_labels
        UpperCamelCase       						=      scope
        UpperCamelCase       						=      len(_SCREAMING_SNAKE_CASE   )

  def 						A__		(   self   )						->   Optional[Any]:



        """simple docstring"""






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

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

        UpperCamelCase       						=      self.get_config()

        return config, pixel_values, labels

  def 						A__		(   self   )						->   Dict:



        """simple docstring"""






        return ResNetConfig(
            num_channels=self.num_channels    ,	embeddings_size=self.embeddings_size    ,	hidden_sizes=self.hidden_sizes    ,	depths=self.depths    ,	hidden_act=self.hidden_act    ,	num_labels=self.num_labels    ,	image_size=self.image_size    ,	)

  def 						A__		(   self    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )						->   Any:



        """simple docstring"""






        UpperCamelCase       						=      TFResNetModel(config=_SCREAMING_SNAKE_CASE   )
        UpperCamelCase       						=      model(_SCREAMING_SNAKE_CASE   )
        # expected last hidden states: B, C, H // 32, W // 32
        self.parent.assertEqual(
            result.last_hidden_state.shape    ,	(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)    ,	)

  def 						A__		(   self    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )						->   List[Any]:



        """simple docstring"""






        UpperCamelCase       						=      self.num_labels
        UpperCamelCase       						=      TFResNetForImageClassification(_SCREAMING_SNAKE_CASE   )
        UpperCamelCase       						=      model(_SCREAMING_SNAKE_CASE    ,	labels=_SCREAMING_SNAKE_CASE   )
        self.parent.assertEqual(result.logits.shape    ,	(self.batch_size, self.num_labels)   )


  def 						A__		(   self   )						->   Union[str, Any]:



        """simple docstring"""






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






@require_tf
class        a_		(    __lowercase			, __lowercase			, unittest.TestCase       ):
  lowercase  	=   (TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
  lowercase  	=   (
      {"""feature-extraction""": TFResNetModel, """image-classification""": TFResNetForImageClassification}
      if is_tf_available()
      else {}
  )

  lowercase  	=   False
  lowercase  	=   False
  lowercase  	=   False
  lowercase  	=   False
  lowercase  	=   False

  def 						A__		(   self   )						->   Union[str, Any]:



        """simple docstring"""






        UpperCamelCase       						=      TFResNetModelTester(self   )
        UpperCamelCase       						=      ConfigTester(self    ,	config_class=_SCREAMING_SNAKE_CASE    ,	has_text_modality=_SCREAMING_SNAKE_CASE   )

  def 						A__		(   self   )						->   Any:



        """simple docstring"""






        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 						A__		(   self   )						->   List[str]:



        """simple docstring"""






        return

  @unittest.skip(reason="""ResNet does not use inputs_embeds"""   )
  def 						A__		(   self   )						->   Optional[Any]:



        """simple docstring"""






        pass

  @unittest.skip(reason="""ResNet does not support input and output embeddings"""   )
  def 						A__		(   self   )						->   Tuple:



        """simple docstring"""






        pass

  def 						A__		(   self   )						->   Optional[int]:



        """simple docstring"""






        UpperCamelCase       						=      self.model_tester.prepare_config_and_inputs_for_common()

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

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

  def 						A__		(   self   )						->   Tuple:



        """simple docstring"""






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

  def 						A__		(   self   )						->   Any:



        """simple docstring"""






        def check_hidden_states_output(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   ):
              UpperCamelCase       						=      model_class(_SCREAMING_SNAKE_CASE   )
              UpperCamelCase       						=      model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )   )

              UpperCamelCase       						=      outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

              UpperCamelCase       						=      self.model_tester.num_stages
              self.assertEqual(len(_SCREAMING_SNAKE_CASE   )    ,	expected_num_stages + 1   )

              # ResNet's feature maps are of shape (batch_size, num_channels, height, width)
              self.assertListEqual(
                  list(hidden_states[0].shape[-2:]   )    ,	[self.model_tester.image_size // 4, self.model_tester.image_size // 4]    ,	)

        UpperCamelCase       						=      self.model_tester.prepare_config_and_inputs_for_common()
        UpperCamelCase       						=      ["basic", "bottleneck"]
        for model_class in self.all_model_classes:
              for layer_type in layers_type:
                    UpperCamelCase       						=      layer_type
                    UpperCamelCase       						=      True
                    check_hidden_states_output(_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       						=      True

                    check_hidden_states_output(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )

  def 						A__		(   self   )						->   Any:



        """simple docstring"""






        UpperCamelCase       						=      self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*_SCREAMING_SNAKE_CASE   )


  @slow
  def 						A__		(   self   )						->   Tuple:



        """simple docstring"""






        for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              UpperCamelCase       						=      TFResNetModel.from_pretrained(_SCREAMING_SNAKE_CASE   )
              self.assertIsNotNone(_SCREAMING_SNAKE_CASE   )







def 					lowercase__				(   )->				Optional[int]:
      UpperCamelCase       						=      Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""					)
      return image






@require_tf
@require_vision
class        a_		(    unittest.TestCase       ):

  @cached_property
  def 						A__		(   self   )						->   str:



        """simple docstring"""






        return (
            AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]   )
            if is_vision_available()
            else None
        )


  @slow
  def 						A__		(   self   )						->   List[str]:



        """simple docstring"""






        UpperCamelCase       						=      TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]   )

        UpperCamelCase       						=      self.default_image_processor
        UpperCamelCase       						=      prepare_img()
        UpperCamelCase       						=      image_processor(images=_SCREAMING_SNAKE_CASE    ,	return_tensors="""tf"""   )

        # forward pass
        UpperCamelCase       						=      model(**_SCREAMING_SNAKE_CASE   )

        # verify the logits
        UpperCamelCase       						=      tf.TensorShape((1, 1000)   )
        self.assertEqual(outputs.logits.shape    ,	_SCREAMING_SNAKE_CASE   )

        UpperCamelCase       						=      tf.constant([-1_1.1_0_6_9, -9.7_8_7_7, -8.3_7_7_7]   )

        self.assertTrue(np.allclose(outputs.logits[0, :3].numpy()    ,	_SCREAMING_SNAKE_CASE    ,	atol=1e-4   )   )













'''simple docstring'''

import argparse

import torch
from torch import nn

from transformers import MaMaaaConfig, MaMaaaForConditionalGeneration







def 					lowercase__				(   __UpperCamelCase					)->				Any:
      UpperCamelCase       						=      [
          """encoder.version""",
          """decoder.version""",
          """model.encoder.version""",
          """model.decoder.version""",
          """decoder.output_projection.weight""",
          """_float_tensor""",
          """encoder.embed_positions._float_tensor""",
          """decoder.embed_positions._float_tensor""",
      ]
      for k in ignore_keys:
            state_dict.pop(__UpperCamelCase	,		__UpperCamelCase					)







def 					lowercase__				(   __UpperCamelCase					)->				str:
      UpperCamelCase						,UpperCamelCase       						=      emb.weight.shape
      UpperCamelCase       						=      nn.Linear(__UpperCamelCase	,		__UpperCamelCase	,		bias=__UpperCamelCase					)
      UpperCamelCase       						=      emb.weight.data
      return lin_layer







def 					lowercase__				(   __UpperCamelCase					)->				str:
      UpperCamelCase       						=      torch.load(__UpperCamelCase	,		map_location="""cpu"""					)
      UpperCamelCase       						=      mam_aaa["""args"""] or mam_aaa["""cfg"""]["""model"""]
      UpperCamelCase       						=      mam_aaa["""model"""]
      remove_ignore_keys_(__UpperCamelCase					)
      UpperCamelCase       						=      state_dict["""encoder.embed_tokens.weight"""].shape[0]

      UpperCamelCase       						=      MaMaaaConfig(
          vocab_size=__UpperCamelCase	,		max_position_embeddings=1024	,		encoder_layers=args.encoder_layers	,		decoder_layers=args.decoder_layers	,		encoder_attention_heads=args.encoder_attention_heads	,		decoder_attention_heads=args.decoder_attention_heads	,		encoder_ffn_dim=args.encoder_ffn_embed_dim	,		decoder_ffn_dim=args.decoder_ffn_embed_dim	,		d_model=args.encoder_embed_dim	,		encoder_layerdrop=args.encoder_layerdrop	,		decoder_layerdrop=args.decoder_layerdrop	,		dropout=args.dropout	,		attention_dropout=args.attention_dropout	,		activation_dropout=args.activation_dropout	,		activation_function="""relu"""	,		)

      UpperCamelCase       						=      state_dict["""decoder.embed_tokens.weight"""]
      UpperCamelCase       						=      MaMaaaForConditionalGeneration(__UpperCamelCase					)
      model.model.load_state_dict(__UpperCamelCase	,		strict=__UpperCamelCase					)
      UpperCamelCase       						=      make_linear_from_emb(model.model.shared					)

      return model


if __name__ == "__main__":
     SCREAMING_SNAKE_CASE__											=     argparse.ArgumentParser()
     # Required parameters
     parser.add_argument('fairseq_path', type=str, help='path to a model.pt on local filesystem.')
     parser.add_argument('pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model.')
     SCREAMING_SNAKE_CASE__											=     parser.parse_args()
     SCREAMING_SNAKE_CASE__											=     convert_fairseq_mamaaa_checkpoint_from_disk(args.fairseq_pathß)
     model.save_pretrained(args.pytorch_dump_folder_path)
