






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()
snake_case__   :						Any													=   logging.get_logger(__name__)

snake_case__   :						Dict													=   """Hello world! cécé herlolip"""






def      _snake_case     (__lowercase     ,   __lowercase     ,   __lowercase):
   UpperCamelCase_						=  FairseqRobertaModel.from_pretrained(__lowercase)
   roberta.eval()  # disable dropout
   UpperCamelCase_						=  roberta.model.encoder.sentence_encoder
   UpperCamelCase_						=  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=514     ,   type_vocab_size=1     ,   layer_norm_eps=1e-5     ,   )
   if classification_head:
      UpperCamelCase_						=  roberta.model.classification_heads['mnli'].out_proj.weight.shape[0]

   print('Our RoBERTa config:'     ,   __lowercase)

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

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

   UpperCamelCase_						=  roberta_sent_encoder.layer_norm.weight
   UpperCamelCase_						=  roberta_sent_encoder.layer_norm.bias

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

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

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

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

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

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

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

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

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

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

   UpperCamelCase_						=  model(__lowercase)[0]
   if classification_head:
      UpperCamelCase_						=  roberta.model.classification_heads['mnli'](roberta.extract_features(__lowercase))
   else:
      UpperCamelCase_						=  roberta.model(__lowercase)[0]
   print(our_output.shape     ,   their_output.shape)
   UpperCamelCase_						=  torch.max(torch.abs(our_output - their_output)).item()
   print(f"""max_absolute_diff = {max_absolute_diff}""")  # ~ 1e-7
   UpperCamelCase_						=  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__":
 snake_case__   :						str													=   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."""
 )
 snake_case__   :						int													=   parser.parse_args()
 convert_xlm_roberta_xl_checkpoint_to_pytorch(
     args.roberta_checkpoint_path, args.pytorch_dump_folder_path, args.classification_head
 )












import argparse
import datetime






def 					SCREAMING_SNAKE_CASE__				(							UpperCamelCase__:				str     ):
		SCREAMING_SNAKE_CASE__								=   {
		    """0""": """Sunday""",
		    """1""": """Monday""",
		    """2""": """Tuesday""",
		    """3""": """Wednesday""",
		    """4""": """Thursday""",
		    """5""": """Friday""",
		    """6""": """Saturday""",
		}

		SCREAMING_SNAKE_CASE__								=   {0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 0}

		# Validate
		if not 0 < len(UpperCamelCase__     ) < 11:
				raise ValueError("""Must be 10 characters long"""     )

		# Get month
		SCREAMING_SNAKE_CASE__								=   int(date_input[0] + date_input[1]     )
		# Validate
		if not 0 < m < 13:
				raise ValueError("""Month must be between 1 - 12"""     )

		SCREAMING_SNAKE_CASE__								=   date_input[2]
		# Validate
		if sep_a not in ["-", "/"]:
				raise ValueError("""Date separator must be '-' or '/'"""     )

		# Get day
		SCREAMING_SNAKE_CASE__								=   int(date_input[3] + date_input[4]     )
		# Validate
		if not 0 < d < 32:
				raise ValueError("""Date must be between 1 - 31"""     )

		# Get second separator
		SCREAMING_SNAKE_CASE__								=   date_input[5]
		# Validate
		if sep_a not in ["-", "/"]:
				raise ValueError("""Date separator must be '-' or '/'"""     )

		# Get year
		SCREAMING_SNAKE_CASE__								=   int(date_input[6] + date_input[7] + date_input[8] + date_input[9]     )
		# Arbitrary year range
		if not 45 < y < 8_500:
				raise ValueError(
				    """Year out of range. There has to be some sort of limit...right?"""     )

		# Get datetime obj for validation
		SCREAMING_SNAKE_CASE__								=   datetime.date(int(UpperCamelCase__     )       , int(UpperCamelCase__     )       , int(UpperCamelCase__     )     )

		# Start math
		if m <= 2:
				SCREAMING_SNAKE_CASE__								=   y - 1
				SCREAMING_SNAKE_CASE__								=   m + 12
		# maths var
		SCREAMING_SNAKE_CASE__								=   int(str(UpperCamelCase__     )[:2]     )
		SCREAMING_SNAKE_CASE__								=   int(str(UpperCamelCase__     )[2:]     )
		SCREAMING_SNAKE_CASE__								=   int(2.6 * m - 5.3_9     )
		SCREAMING_SNAKE_CASE__								=   int(c / 4     )
		SCREAMING_SNAKE_CASE__								=   int(k / 4     )
		SCREAMING_SNAKE_CASE__								=   int(d + k     )
		SCREAMING_SNAKE_CASE__								=   int(t + u + v + x     )
		SCREAMING_SNAKE_CASE__								=   int(z - (2 * c)     )
		SCREAMING_SNAKE_CASE__								=   round(w % 7     )
		# End math

		# Validate math
		if f != convert_datetime_days[dt_ck.weekday()]:
				raise AssertionError("""The date was evaluated incorrectly. Contact developer."""     )

		# Response
		SCREAMING_SNAKE_CASE__								=   f'''Your date {date_input}, is a {days[str(UpperCamelCase__     )]}!'''
		return response


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	_lowerCamelCase 					=      argparse.ArgumentParser(
	    description=(
	        'Find out what day of the week nearly any date is or was. Enter '
	        'date as a string in the mm-dd-yyyy or mm/dd/yyyy format'
	    )
	)
	parser.add_argument(
	    'date_input', type=str, help='Date as a string (mm-dd-yyyy or mm/dd/yyyy)'
	)
	_lowerCamelCase 					=      parser.parse_args()
	zeller(args.date_input)