

'''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()
__lowerCamelCase						    =      logging.get_logger(__name__)

__lowerCamelCase						    =      '''Hello world! cécé herlolip'''
def  UpperCAmelCase__      ( UpperCAmelCase__,    UpperCAmelCase__,    UpperCAmelCase__			)     ->     str:
       A_		   = FairseqRobertaModel.from_pretrained(UpperCAmelCase__			)
       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_14,    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:""",    UpperCAmelCase__			)

       A_		   = XLMRobertaXLForSequenceClassification(UpperCAmelCase__			) if classification_head else XLMRobertaXLForMaskedLM(UpperCAmelCase__			)
       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(UpperCAmelCase__			).unsqueeze(0			)  # batch of size 1

       A_		   = model(UpperCAmelCase__			)[0]
       if classification_head:
              A_		   = roberta.model.classification_heads["""mnli"""](roberta.extract_features(UpperCAmelCase__			)			)
       else:
              A_		   = roberta.model(UpperCAmelCase__			)[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(UpperCAmelCase__,    UpperCAmelCase__,    atol=1e-3			)
       print("""Do both models output the same tensors?""",    """🔥""" if success else """💩"""			)
       if not success:
              raise Exception("""Something went wRoNg"""			)

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


if __name__ == "__main__":
      __lowerCamelCase						    =      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.'''
      )
      __lowerCamelCase						    =      parser.parse_args()
      convert_xlm_roberta_xl_checkpoint_to_pytorch(
          args.roberta_checkpoint_path, args.pytorch_dump_folder_path, args.classification_head
      )



'''simple docstring'''







import sys

__lowerCamelCase						    =      (
    '''73167176531330624919225119674426574742355349194934'''
    '''96983520312774506326239578318016984801869478851843'''
    '''85861560789112949495459501737958331952853208805511'''
    '''12540698747158523863050715693290963295227443043557'''
    '''66896648950445244523161731856403098711121722383113'''
    '''62229893423380308135336276614282806444486645238749'''
    '''30358907296290491560440772390713810515859307960866'''
    '''70172427121883998797908792274921901699720888093776'''
    '''65727333001053367881220235421809751254540594752243'''
    '''52584907711670556013604839586446706324415722155397'''
    '''53697817977846174064955149290862569321978468622482'''
    '''83972241375657056057490261407972968652414535100474'''
    '''82166370484403199890008895243450658541227588666881'''
    '''16427171479924442928230863465674813919123162824586'''
    '''17866458359124566529476545682848912883142607690042'''
    '''24219022671055626321111109370544217506941658960408'''
    '''07198403850962455444362981230987879927244284909188'''
    '''84580156166097919133875499200524063689912560717606'''
    '''05886116467109405077541002256983155200055935729725'''
    '''71636269561882670428252483600823257530420752963450'''
)
def  UpperCAmelCase__      ( UpperCAmelCase__ = N			)     ->     int:
       A_		   = -sys.maxsize - 1
       for i in range(len(UpperCAmelCase__			) - 12			):
              A_		   = 1
              for j in range(13			):
                     product *= int(n[i + j]			)
              if product > largest_product:
                     A_		   = product
       return largest_product


if __name__ == "__main__":
      print(f"""{solution() = }""")
