




'''simple docstring'''



class      lowerCAmelCase :


       def __init__( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE=None     ,	__SCREAMING_SNAKE_CASE=None	)   ->	Dict:



            '''simple docstring'''




            __snake_case            =	data
            __snake_case            =	previous
            __snake_case            =	next_node


       def __str__( self	)   ->	str:



            '''simple docstring'''




            return F'''{self.data}'''


       def    lowerCAmelCase   ( self	)   ->	int:



            '''simple docstring'''




            return self.data


       def    lowerCAmelCase   ( self	)   ->	Dict:



            '''simple docstring'''




            return self.next




       def    lowerCAmelCase   ( self	)   ->	int:



            '''simple docstring'''




            return self.previous





class      lowerCAmelCase :


       def __init__( self     ,	__SCREAMING_SNAKE_CASE	)   ->	Tuple:



            '''simple docstring'''




            __snake_case            =	head


       def __iter__( self	)   ->	Any:



            '''simple docstring'''




            return self




       def    lowerCAmelCase   ( self	)   ->	Tuple:



            '''simple docstring'''




            if not self.current:
                 raise StopIteration
            else:
                 __snake_case            =	self.current.get_data()
                 __snake_case            =	self.current.get_next()
                 return value





class      lowerCAmelCase :


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



            '''simple docstring'''




            __snake_case            =	None  # First node in list
            __snake_case            =	None  # Last node in list


       def __str__( self	)   ->	Any:



            '''simple docstring'''




            __snake_case            =	self.head
            __snake_case            =	[]
            while current is not None:
                 nodes.append(current.get_data()	)
                 __snake_case            =	current.get_next()
            return " ".join(str(__SCREAMING_SNAKE_CASE	) for node in nodes	)


       def __contains__( self     ,	__SCREAMING_SNAKE_CASE	)   ->	Optional[Any]:



            '''simple docstring'''




            __snake_case            =	self.head
            while current:
                 if current.get_data() == value:
                      return True
                 __snake_case            =	current.get_next()
            return False


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



            '''simple docstring'''




            return LinkedListIterator(self.head	)


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



            '''simple docstring'''




            if self.head:
                 return self.head.get_data()
            return None


       def    lowerCAmelCase   ( self	)   ->	Tuple:



            '''simple docstring'''




            if self.tail:
                 return self.tail.get_data()
            return None


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE	)   ->	None:



            '''simple docstring'''




            if self.head is None:
                 __snake_case            =	node
                 __snake_case            =	node
            else:
                 self.insert_before_node(self.head     ,	__SCREAMING_SNAKE_CASE	)


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE	)   ->	None:



            '''simple docstring'''




            if self.head is None:
                 self.set_head(__SCREAMING_SNAKE_CASE	)
            else:
                 self.insert_after_node(self.tail     ,	__SCREAMING_SNAKE_CASE	)


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE	)   ->	None:



            '''simple docstring'''




            __snake_case            =	Node(__SCREAMING_SNAKE_CASE	)
            if self.head is None:
                 self.set_head(__SCREAMING_SNAKE_CASE	)
            else:
                 self.set_tail(__SCREAMING_SNAKE_CASE	)


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)   ->	None:



            '''simple docstring'''




            __snake_case            =	node
            __snake_case            =	node.previous

            if node.get_previous() is None:
                 __snake_case            =	node_to_insert
            else:
                 __snake_case            =	node_to_insert

            __snake_case            =	node_to_insert


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)   ->	None:



            '''simple docstring'''




            __snake_case            =	node
            __snake_case            =	node.next

            if node.get_next() is None:
                 __snake_case            =	node_to_insert
            else:
                 __snake_case            =	node_to_insert

            __snake_case            =	node_to_insert


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)   ->	None:



            '''simple docstring'''




            __snake_case            =	1
            __snake_case            =	Node(__SCREAMING_SNAKE_CASE	)
            __snake_case            =	self.head
            while node:
                 if current_position == position:
                      self.insert_before_node(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)
                      return
                 current_position += 1
                 __snake_case            =	node.next
            self.insert_after_node(self.tail     ,	__SCREAMING_SNAKE_CASE	)


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE	)   ->	Node:



            '''simple docstring'''




            __snake_case            =	self.head
            while node:
                 if node.get_data() == item:
                      return node
                 __snake_case            =	node.get_next()
            raise Exception('''Node not found'''	)


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



            '''simple docstring'''




            if (node := self.get_node(__SCREAMING_SNAKE_CASE	)) is not None:
                 if node == self.head:
                      __snake_case            =	self.head.get_next()

                 if node == self.tail:
                      __snake_case            =	self.tail.get_previous()

                 self.remove_node_pointers(__SCREAMING_SNAKE_CASE	)


       @staticmethod
       def    lowerCAmelCase   ( __SCREAMING_SNAKE_CASE	)   ->	None:



            '''simple docstring'''




            if node.get_next():
                 __snake_case            =	node.previous

            if node.get_previous():
                 __snake_case            =	node.next

            __snake_case            =	None
            __snake_case            =	None




       def    lowerCAmelCase   ( self	)   ->	Tuple:



            '''simple docstring'''




            return self.head is None







def       _UpperCamelCase			()-> None:




     '''simple docstring'''







if __name__ == "__main__":
     import doctest

     doctest.testmod()














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()
__a   :							Union[str, Any]						= logging.get_logger(__name__)

__a   :							Tuple						= "Hello world! cécé herlolip"



def       _SCREAMING_SNAKE_CASE    (			__lowercase :      str      ,					__lowercase :      str      ,					__lowercase :      bool     )    ->   List[Any]:





    """simple docstring"""

    __A       =						FairseqRobertaModel.from_pretrained(__lowercase     )
    roberta.eval()  # disable dropout
    __A       =						roberta.model.encoder.sentence_encoder
    __A       =						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_1_4      ,					type_vocab_size=1      ,					layer_norm_eps=1E-5      ,					)
    if classification_head:
        __A       =						roberta.model.classification_heads["""mnli"""].out_proj.weight.shape[0]

    print("""Our RoBERTa config:"""      ,					__lowercase     )

    __A       =						XLMRobertaXLForSequenceClassification(__lowercase     ) if classification_head else XLMRobertaXLForMaskedLM(__lowercase     )
    model.eval()

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

    __A       =						roberta_sent_encoder.layer_norm.weight
    __A       =						roberta_sent_encoder.layer_norm.bias

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

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

        # self attention
        __A       =						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)     )
        )

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

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

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

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

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

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

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

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

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


if __name__ == "__main__":
  __a   :							List[Any]						= 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."
  )
  __a   :							Dict						= parser.parse_args()
  convert_xlm_roberta_xl_checkpoint_to_pytorch(
      args.roberta_checkpoint_path, args.pytorch_dump_folder_path, args.classification_head
  )




