
"""simple docstring"""



import argparse
import pathlib

import fairseq
import torch
from fairseq.models.roberta import RobertaModel as FairseqRobertaModel
from fairseq.modules import TransformerSentenceEncoderLayer
from packaging import version

from transformers import XLMRobertaConfig, XLMRobertaXLForMaskedLM, XLMRobertaXLForSequenceClassification
from transformers.models.bert.modeling_bert import (
    BertIntermediate,
    BertLayer,
    BertOutput,
    BertSelfAttention,
    BertSelfOutput,
)
from transformers.models.roberta.modeling_roberta import RobertaAttention
from transformers.utils import logging


if version.parse(fairseq.__version__) < version.parse('1.0.0a'):
 raise Exception('requires fairseq >= 1.0.0a')

logging.set_verbosity_info()
UpperCAmelCase__          = logging.get_logger(__name__)

UpperCAmelCase__          = 'Hello world! cécé herlolip'
def 					_UpperCAmelCase      ( __lowerCamelCase   :       str ,					__lowerCamelCase   :       str ,					__lowerCamelCase   :       bool		)     ->					Optional[int]:
  _snake_case					     =       FairseqRobertaModel.from_pretrained(__lowerCamelCase		)
  roberta.eval()  # disable dropout
  _snake_case					     =       roberta.model.encoder.sentence_encoder
  _snake_case					     =       XLMRobertaConfig(
      vocab_size=roberta_sent_encoder.embed_tokens.num_embeddings ,					hidden_size=roberta.cfg.model.encoder_embed_dim ,					num_hidden_layers=roberta.cfg.model.encoder_layers ,					num_attention_heads=roberta.cfg.model.encoder_attention_heads ,					intermediate_size=roberta.cfg.model.encoder_ffn_embed_dim ,					max_position_embeddings=5_14 ,					type_vocab_size=1 ,					layer_norm_eps=1E-5 ,					)
  if classification_head:
    _snake_case					     =       roberta.model.classification_heads['''mnli'''].out_proj.weight.shape[0]

  print('''Our RoBERTa config:''' ,					__lowerCamelCase		)

  _snake_case					     =       XLMRobertaXLForSequenceClassification(__lowerCamelCase		) if classification_head else XLMRobertaXLForMaskedLM(__lowerCamelCase		)
  model.eval()

  # Now let's copy all the weights.
  # Embeddings
  _snake_case					     =       roberta_sent_encoder.embed_tokens.weight
  _snake_case					     =       roberta_sent_encoder.embed_positions.weight
  _snake_case					     =       torch.zeros_like(
      model.roberta.embeddings.token_type_embeddings.weight		)  # just zero them out b/c RoBERTa doesn't use them.

  _snake_case					     =       roberta_sent_encoder.layer_norm.weight
  _snake_case					     =       roberta_sent_encoder.layer_norm.bias

  for i in range(config.num_hidden_layers		):
    # Encoder: start of layer
    _snake_case					     =       model.roberta.encoder.layer[i]
    _snake_case					     =       roberta_sent_encoder.layers[i]

    _snake_case					     =       layer.attention
    _snake_case					     =       roberta_layer.self_attn_layer_norm.weight
    _snake_case					     =       roberta_layer.self_attn_layer_norm.bias

    # self attention
    _snake_case					     =       layer.attention.self
    assert (
        roberta_layer.self_attn.k_proj.weight.data.shape
        == roberta_layer.self_attn.q_proj.weight.data.shape
        == roberta_layer.self_attn.v_proj.weight.data.shape
        == torch.Size((config.hidden_size, config.hidden_size)		)
    )

    _snake_case					     =       roberta_layer.self_attn.q_proj.weight
    _snake_case					     =       roberta_layer.self_attn.q_proj.bias
    _snake_case					     =       roberta_layer.self_attn.k_proj.weight
    _snake_case					     =       roberta_layer.self_attn.k_proj.bias
    _snake_case					     =       roberta_layer.self_attn.v_proj.weight
    _snake_case					     =       roberta_layer.self_attn.v_proj.bias

    # self-attention output
    _snake_case					     =       layer.attention.output
    assert self_output.dense.weight.shape == roberta_layer.self_attn.out_proj.weight.shape
    _snake_case					     =       roberta_layer.self_attn.out_proj.weight
    _snake_case					     =       roberta_layer.self_attn.out_proj.bias

    # this one is final layer norm
    _snake_case					     =       roberta_layer.final_layer_norm.weight
    _snake_case					     =       roberta_layer.final_layer_norm.bias

    # intermediate
    _snake_case					     =       layer.intermediate
    assert intermediate.dense.weight.shape == roberta_layer.fca.weight.shape
    _snake_case					     =       roberta_layer.fca.weight
    _snake_case					     =       roberta_layer.fca.bias

    # output
    _snake_case					     =       layer.output
    assert bert_output.dense.weight.shape == roberta_layer.fca.weight.shape
    _snake_case					     =       roberta_layer.fca.weight
    _snake_case					     =       roberta_layer.fca.bias
    # end of layer

  if classification_head:
    _snake_case					     =       roberta.model.classification_heads['''mnli'''].dense.weight
    _snake_case					     =       roberta.model.classification_heads['''mnli'''].dense.bias
    _snake_case					     =       roberta.model.classification_heads['''mnli'''].out_proj.weight
    _snake_case					     =       roberta.model.classification_heads['''mnli'''].out_proj.bias
  else:
    # LM Head
    _snake_case					     =       roberta.model.encoder.lm_head.dense.weight
    _snake_case					     =       roberta.model.encoder.lm_head.dense.bias
    _snake_case					     =       roberta.model.encoder.lm_head.layer_norm.weight
    _snake_case					     =       roberta.model.encoder.lm_head.layer_norm.bias
    _snake_case					     =       roberta.model.encoder.lm_head.weight
    _snake_case					     =       roberta.model.encoder.lm_head.bias

  # Let's check that we get the same results.
  _snake_case					     =       roberta.encode(__lowerCamelCase		).unsqueeze(0		)  # batch of size 1

  _snake_case					     =       model(__lowerCamelCase		)[0]
  if classification_head:
    _snake_case					     =       roberta.model.classification_heads['''mnli'''](roberta.extract_features(__lowerCamelCase		)		)
  else:
    _snake_case					     =       roberta.model(__lowerCamelCase		)[0]
  print(our_output.shape ,					their_output.shape		)
  _snake_case					     =       torch.max(torch.abs(our_output - their_output		)		).item()
  print(f'''max_absolute_diff = {max_absolute_diff}'''		)  # ~ 1e-7
  _snake_case					     =       torch.allclose(__lowerCamelCase ,					__lowerCamelCase ,					atol=1E-3		)
  print('''Do both models output the same tensors?''' ,					'''🔥''' if success else '''💩'''		)
  if not success:
    raise Exception('''Something went wRoNg'''		)

  pathlib.Path(__lowerCamelCase		).mkdir(parents=__lowerCamelCase ,					exist_ok=__lowerCamelCase		)
  print(f'''Saving model to {pytorch_dump_folder_path}'''		)
  model.save_pretrained(__lowerCamelCase		)


if __name__ == "__main__":
 UpperCAmelCase__          = argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     '--roberta_checkpoint_path', default=None, type=str, required=True, help='Path the official PyTorch dump.'
 )
 parser.add_argument(
     '--pytorch_dump_folder_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
 )
 parser.add_argument(
     '--classification_head', action='store_true', help='Whether to convert a final classification head.'
 )
 UpperCAmelCase__          = parser.parse_args()
 convert_xlm_roberta_xl_checkpoint_to_pytorch(
     args.roberta_checkpoint_path, args.pytorch_dump_folder_path, args.classification_head
 )





"""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       lowerCAmelCase__				:







     def __init__(							self			:			Dict    ,      _lowerCamelCase			:			int    ,      _lowerCamelCase			:			Optional[int]=3    ,      _lowerCamelCase			:			List[str]=32    ,      _lowerCamelCase			:			Optional[int]=3    ,      _lowerCamelCase			:			Dict=10    ,      _lowerCamelCase			:			Tuple=[10, 20, 30, 40]    ,      _lowerCamelCase			:			int=[1, 1, 2, 1]    ,      _lowerCamelCase			:			int=True    ,      _lowerCamelCase			:			Optional[int]=True    ,      _lowerCamelCase			:			Optional[int]="relu"    ,      _lowerCamelCase			:			List[Any]=3    ,      _lowerCamelCase			:			Dict=None    ,      ):
       _snake_case					     =       parent
       _snake_case					     =       batch_size
       _snake_case					     =       image_size
       _snake_case					     =       num_channels
       _snake_case					     =       embeddings_size
       _snake_case					     =       hidden_sizes
       _snake_case					     =       depths
       _snake_case					     =       is_training
       _snake_case					     =       use_labels
       _snake_case					     =       hidden_act
       _snake_case					     =       num_labels
       _snake_case					     =       scope
       _snake_case					     =       len(_lowerCamelCase			)







     def      lowercase	(							self			:			Optional[int]			):
       _snake_case					     =       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

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

       _snake_case					     =       self.get_config()

       return config, pixel_values, labels







     def      lowercase	(							self			:			Tuple			):
       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      lowercase	(							self			:			List[Any]    ,      _lowerCamelCase			:			List[str]    ,      _lowerCamelCase			:			str    ,      _lowerCamelCase			:			List[Any]			):
       _snake_case					     =       TFResNetModel(config=_lowerCamelCase			)
       _snake_case					     =       model(_lowerCamelCase			)
       # 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      lowercase	(							self			:			Dict    ,      _lowerCamelCase			:			str    ,      _lowerCamelCase			:			Optional[Any]    ,      _lowerCamelCase			:			Tuple			):
       _snake_case					     =       self.num_labels
       _snake_case					     =       TFResNetForImageClassification(_lowerCamelCase			)
       _snake_case					     =       model(_lowerCamelCase    ,      labels=_lowerCamelCase			)
       self.parent.assertEqual(result.logits.shape    ,      (self.batch_size, self.num_labels)			)







     def      lowercase	(							self			:			Tuple			):
       _snake_case					     =       self.prepare_config_and_inputs()
       _snake_case     ,					_snake_case     ,					_snake_case					     =       config_and_inputs
       _snake_case					     =       {'''pixel_values''': pixel_values}
       return config, inputs_dict






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

     __a						=					False
     __a						=					False
     __a						=					False
     __a						=					False
     __a						=					False







     def      lowercase	(							self			:			List[Any]			):
       _snake_case					     =       TFResNetModelTester(self			)
       _snake_case					     =       ConfigTester(self    ,      config_class=_lowerCamelCase    ,      has_text_modality=_lowerCamelCase			)







     def      lowercase	(							self			:			Tuple			):
       self.create_and_test_config_common_properties()
       self.config_tester.create_and_test_config_to_json_string()
       self.config_tester.create_and_test_config_to_json_file()
       self.config_tester.create_and_test_config_from_and_save_pretrained()
       self.config_tester.create_and_test_config_with_num_labels()
       self.config_tester.check_config_can_be_init_without_params()
       self.config_tester.check_config_arguments_init()







     def      lowercase	(							self			:			List[Any]			):
       return







     @unittest.skip(reason='''ResNet does not use inputs_embeds'''			)
     def      lowercase	(							self			:			Any			):
       pass







     @unittest.skip(reason='''ResNet does not support input and output embeddings'''			)
     def      lowercase	(							self			:			List[str]			):
       pass







     def      lowercase	(							self			:			int			):
       _snake_case     ,					_snake_case					     =       self.model_tester.prepare_config_and_inputs_for_common()

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

         _snake_case					     =       ['''pixel_values''']
         self.assertListEqual(arg_names[:1]    ,      _lowerCamelCase			)







     def      lowercase	(							self			:			List[str]			):
       _snake_case					     =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_lowerCamelCase			)







     def      lowercase	(							self			:			Union[str, Any]			):
       def check_hidden_states_output(_lowerCamelCase			:			int    ,      _lowerCamelCase			:			List[Any]    ,      _lowerCamelCase			:			str			):
         _snake_case					     =       model_class(_lowerCamelCase			)
         _snake_case					     =       model(**self._prepare_for_class(_lowerCamelCase    ,      _lowerCamelCase			)			)

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

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

       _snake_case     ,					_snake_case					     =       self.model_tester.prepare_config_and_inputs_for_common()
       _snake_case					     =       ['''basic''', '''bottleneck''']
       for model_class in self.all_model_classes:
         for layer_type in layers_type:
           _snake_case					     =       layer_type
           _snake_case					     =       True
           check_hidden_states_output(_lowerCamelCase    ,      _lowerCamelCase    ,      _lowerCamelCase			)

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

           check_hidden_states_output(_lowerCamelCase    ,      _lowerCamelCase    ,      _lowerCamelCase			)







     def      lowercase	(							self			:			Union[str, Any]			):
       _snake_case					     =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*_lowerCamelCase			)







     @slow
     def      lowercase	(							self			:			List[str]			):
       for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         _snake_case					     =       TFResNetModel.from_pretrained(_lowerCamelCase			)
         self.assertIsNotNone(_lowerCamelCase			)






def 					_UpperCAmelCase      ( )     ->					Union[str, Any]:
  _snake_case					     =       Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''		)
  return image

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







     @cached_property
     def      lowercase	(							self			:			Dict			):
       return (
           AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]			)
           if is_vision_available()
           else None
       )







     @slow
     def      lowercase	(							self			:			List[Any]			):
       _snake_case					     =       TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]			)

       _snake_case					     =       self.default_image_processor
       _snake_case					     =       prepare_img()
       _snake_case					     =       image_processor(images=_lowerCamelCase    ,      return_tensors='''tf'''			)

       # forward pass
       _snake_case					     =       model(**_lowerCamelCase			)

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

       _snake_case					     =       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()    ,      _lowerCamelCase    ,      atol=1e-4			)			)



