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





       """simple docstring"""




       def __init__(							self       ,							A__       ,							A__=3       ,							A__=32       ,							A__=3       ,							A__=10       ,							A__=[10, 20, 30, 40]       ,							A__=[1, 1, 2, 1]       ,							A__=True       ,							A__=True       ,							A__="relu"       ,							A__=3       ,							A__=None       ,							)    ->			List[str]:
          _SCREAMING_SNAKE_CASE      =				parent
          _SCREAMING_SNAKE_CASE      =				batch_size
          _SCREAMING_SNAKE_CASE      =				image_size
          _SCREAMING_SNAKE_CASE      =				num_channels
          _SCREAMING_SNAKE_CASE      =				embeddings_size
          _SCREAMING_SNAKE_CASE      =				hidden_sizes
          _SCREAMING_SNAKE_CASE      =				depths
          _SCREAMING_SNAKE_CASE      =				is_training
          _SCREAMING_SNAKE_CASE      =				use_labels
          _SCREAMING_SNAKE_CASE      =				hidden_act
          _SCREAMING_SNAKE_CASE      =				num_labels
          _SCREAMING_SNAKE_CASE      =				scope
          _SCREAMING_SNAKE_CASE      =				len(A__      )






       def        UpperCamelCase				(							self      )    ->			Tuple:
          _SCREAMING_SNAKE_CASE      =				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

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

          _SCREAMING_SNAKE_CASE      =				self.get_config()

          return config, pixel_values, labels






       def        UpperCamelCase				(							self      )    ->			Optional[int]:
          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        UpperCamelCase				(							self       ,							A__       ,							A__       ,							A__      )    ->			int:
          _SCREAMING_SNAKE_CASE      =				TFResNetModel(config=A__      )
          _SCREAMING_SNAKE_CASE      =				model(A__      )
          # 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        UpperCamelCase				(							self       ,							A__       ,							A__       ,							A__      )    ->			Tuple:
          _SCREAMING_SNAKE_CASE      =				self.num_labels
          _SCREAMING_SNAKE_CASE      =				TFResNetForImageClassification(A__      )
          _SCREAMING_SNAKE_CASE      =				model(A__       ,							labels=A__      )
          self.parent.assertEqual(result.logits.shape       ,							(self.batch_size, self.num_labels)      )






       def        UpperCamelCase				(							self      )    ->			List[str]:
          _SCREAMING_SNAKE_CASE      =				self.prepare_config_and_inputs()
          _SCREAMING_SNAKE_CASE ,							_SCREAMING_SNAKE_CASE ,							_SCREAMING_SNAKE_CASE      =				config_and_inputs
          _SCREAMING_SNAKE_CASE      =				{"""pixel_values""": pixel_values}
          return config, inputs_dict






@require_tf
class    _a				(_lowerCamelCase  ,					_lowerCamelCase  ,					unittest.TestCase):





       """simple docstring"""




       SCREAMING_SNAKE_CASE      =  (TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
       SCREAMING_SNAKE_CASE      =  (
           {'feature-extraction': TFResNetModel, 'image-classification': TFResNetForImageClassification}
           if is_tf_available()
           else {}
       )

       SCREAMING_SNAKE_CASE      =  False
       SCREAMING_SNAKE_CASE      =  False
       SCREAMING_SNAKE_CASE      =  False
       SCREAMING_SNAKE_CASE      =  False
       SCREAMING_SNAKE_CASE      =  False






       def        UpperCamelCase				(							self      )    ->			Union[str, Any]:
          _SCREAMING_SNAKE_CASE      =				TFResNetModelTester(self      )
          _SCREAMING_SNAKE_CASE      =				ConfigTester(self       ,							config_class=A__       ,							has_text_modality=A__      )






       def        UpperCamelCase				(							self      )    ->			int:
          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      )    ->			str:
          return






       @unittest.skip(reason="""ResNet does not use inputs_embeds"""      )
       def        UpperCamelCase				(							self      )    ->			Tuple:
          pass






       @unittest.skip(reason="""ResNet does not support input and output embeddings"""      )
       def        UpperCamelCase				(							self      )    ->			Union[str, Any]:
          pass






       def        UpperCamelCase				(							self      )    ->			str:
          _SCREAMING_SNAKE_CASE ,							_SCREAMING_SNAKE_CASE      =				self.model_tester.prepare_config_and_inputs_for_common()

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

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






       def        UpperCamelCase				(							self      )    ->			List[str]:
          _SCREAMING_SNAKE_CASE      =				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*A__      )






       def        UpperCamelCase				(							self      )    ->			Optional[Any]:
          def check_hidden_states_output(A__       ,							A__       ,							A__      ):
             _SCREAMING_SNAKE_CASE      =				model_class(A__      )
             _SCREAMING_SNAKE_CASE      =				model(**self._prepare_for_class(A__       ,							A__      )      )

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

             _SCREAMING_SNAKE_CASE      =				self.model_tester.num_stages
             self.assertEqual(len(A__      )       ,							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]       ,							)

          _SCREAMING_SNAKE_CASE ,							_SCREAMING_SNAKE_CASE      =				self.model_tester.prepare_config_and_inputs_for_common()
          _SCREAMING_SNAKE_CASE      =				["""basic""", """bottleneck"""]
          for model_class in self.all_model_classes:
             for layer_type in layers_type:
                _SCREAMING_SNAKE_CASE      =				layer_type
                _SCREAMING_SNAKE_CASE      =				True
                check_hidden_states_output(A__       ,							A__       ,							A__      )

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

                check_hidden_states_output(A__       ,							A__       ,							A__      )






       def        UpperCamelCase				(							self      )    ->			int:
          _SCREAMING_SNAKE_CASE      =				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*A__      )






       @slow
       def        UpperCamelCase				(							self      )    ->			List[Any]:
          for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             _SCREAMING_SNAKE_CASE      =				TFResNetModel.from_pretrained(A__      )
             self.assertIsNotNone(A__      )






def    lowerCAmelCase_	(				)     ->     str:




   """simple docstring"""
   _SCREAMING_SNAKE_CASE      =				Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""						)
   return image







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





       """simple docstring"""




       @cached_property
       def        UpperCamelCase				(							self      )    ->			Any:
          return (
              AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]      )
              if is_vision_available()
              else None
          )






       @slow
       def        UpperCamelCase				(							self      )    ->			str:
          _SCREAMING_SNAKE_CASE      =				TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]      )

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

          # forward pass
          _SCREAMING_SNAKE_CASE      =				model(**A__      )

          # verify the logits
          _SCREAMING_SNAKE_CASE      =				tf.TensorShape((1, 10_00)      )
          self.assertEqual(outputs.logits.shape       ,							A__      )

          _SCREAMING_SNAKE_CASE      =				tf.constant([-11.1069, -9.7877, -8.3777]      )

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








'''simple docstring'''



import argparse

import torch
from torch import nn

from transformers import MaMaaaConfig, MaMaaaForConditionalGeneration
def    lowerCAmelCase_	(				SCREAMING_SNAKE_CASE_						)     ->     Any:




   """simple docstring"""
   _SCREAMING_SNAKE_CASE      =				[
       """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(SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_						)
def    lowerCAmelCase_	(				SCREAMING_SNAKE_CASE_						)     ->     str:




   """simple docstring"""
   _SCREAMING_SNAKE_CASE ,							_SCREAMING_SNAKE_CASE      =				emb.weight.shape
   _SCREAMING_SNAKE_CASE      =				nn.Linear(SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_    ,      bias=SCREAMING_SNAKE_CASE_						)
   _SCREAMING_SNAKE_CASE      =				emb.weight.data
   return lin_layer
def    lowerCAmelCase_	(				SCREAMING_SNAKE_CASE_						)     ->     List[Any]:




   """simple docstring"""
   _SCREAMING_SNAKE_CASE      =				torch.load(SCREAMING_SNAKE_CASE_    ,      map_location="""cpu"""						)
   _SCREAMING_SNAKE_CASE      =				mam_aaa["""args"""] or mam_aaa["""cfg"""]["""model"""]
   _SCREAMING_SNAKE_CASE      =				mam_aaa["""model"""]
   remove_ignore_keys_(SCREAMING_SNAKE_CASE_						)
   _SCREAMING_SNAKE_CASE      =				state_dict["""encoder.embed_tokens.weight"""].shape[0]

   _SCREAMING_SNAKE_CASE      =				MaMaaaConfig(
       vocab_size=SCREAMING_SNAKE_CASE_    ,      max_position_embeddings=10_24    ,      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"""    ,      )

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

   return model


if __name__ == "__main__":
     UpperCamelCase__      :		Dict       							=  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.")
     UpperCamelCase__      :		List[str]       							=  parser.parse_args()
     UpperCamelCase__      :		Any       							=  convert_fairseq_mamaaa_checkpoint_from_disk(args.fairseq_pathß)
     model.save_pretrained(args.pytorch_dump_folder_path)






