






import os
import unittest

from transformers import ElectraTokenizerFast
from transformers.models.electra.tokenization_electra import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    ElectraTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english





@require_tokenizers
class __lowerCamelCase					( snake_case__	,			unittest.TestCase):





	"""simple docstring"""






	UpperCamelCase__								= ElectraTokenizer
	UpperCamelCase__								= ElectraTokenizerFast
	UpperCamelCase__								= True
	UpperCamelCase__								= True
	UpperCamelCase__								= filter_non_english

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							super().setUp()

							_UpperCAmelCase							   =     [
							    '[UNK]',
							    '[CLS]',
							    '[SEP]',
							    '[PAD]',
							    '[MASK]',
							    'want',
							    '##want',
							    '##ed',
							    'wa',
							    'un',
							    'runn',
							    '##ing',
							    ',',
							    'low',
							    'lowest',
							]
							_UpperCAmelCase							   =     os.path.join(self.tmpdirname			,       VOCAB_FILES_NAMES['vocab_file']       )
							with open(self.vocab_file			,       'w'			,       encoding='utf-8'       ) as vocab_writer:
													vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]       )       )

	def 			UpperCamelCase       (				self			,       UpperCAmelCase       ):
							"""simple docstring"""







							_UpperCAmelCase							   =     'UNwant\u00E9d,running'
							_UpperCAmelCase							   =     'unwanted, running'
							return input_text, output_text

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							_UpperCAmelCase							   =     self.tokenizer_class(self.vocab_file       )

							_UpperCAmelCase							   =     tokenizer.tokenize('UNwant\u00E9d,running'       )
							self.assertListEqual(UpperCAmelCase			,       ['un', '##want', '##ed', ',', 'runn', '##ing']       )
							self.assertListEqual(tokenizer.convert_tokens_to_ids(UpperCAmelCase       )			,       [9, 6, 7, 12, 10, 11]       )

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							if not self.test_rust_tokenizer:
													return

							_UpperCAmelCase							   =     self.get_tokenizer()
							_UpperCAmelCase							   =     self.get_rust_tokenizer()

							_UpperCAmelCase							   =     'UNwant\u00E9d,running'

							_UpperCAmelCase							   =     tokenizer.tokenize(UpperCAmelCase       )
							_UpperCAmelCase							   =     rust_tokenizer.tokenize(UpperCAmelCase       )
							self.assertListEqual(UpperCAmelCase			,       UpperCAmelCase       )

							_UpperCAmelCase							   =     tokenizer.encode(UpperCAmelCase			,       add_special_tokens=UpperCAmelCase       )
							_UpperCAmelCase							   =     rust_tokenizer.encode(UpperCAmelCase			,       add_special_tokens=UpperCAmelCase       )
							self.assertListEqual(UpperCAmelCase			,       UpperCAmelCase       )

							_UpperCAmelCase							   =     self.get_rust_tokenizer()
							_UpperCAmelCase							   =     tokenizer.encode(UpperCAmelCase       )
							_UpperCAmelCase							   =     rust_tokenizer.encode(UpperCAmelCase       )
							self.assertListEqual(UpperCAmelCase			,       UpperCAmelCase       )

							# With lower casing
							_UpperCAmelCase							   =     self.get_tokenizer(do_lower_case=UpperCAmelCase       )
							_UpperCAmelCase							   =     self.get_rust_tokenizer(do_lower_case=UpperCAmelCase       )

							_UpperCAmelCase							   =     'UNwant\u00E9d,running'

							_UpperCAmelCase							   =     tokenizer.tokenize(UpperCAmelCase       )
							_UpperCAmelCase							   =     rust_tokenizer.tokenize(UpperCAmelCase       )
							self.assertListEqual(UpperCAmelCase			,       UpperCAmelCase       )

							_UpperCAmelCase							   =     tokenizer.encode(UpperCAmelCase			,       add_special_tokens=UpperCAmelCase       )
							_UpperCAmelCase							   =     rust_tokenizer.encode(UpperCAmelCase			,       add_special_tokens=UpperCAmelCase       )
							self.assertListEqual(UpperCAmelCase			,       UpperCAmelCase       )

							_UpperCAmelCase							   =     self.get_rust_tokenizer()
							_UpperCAmelCase							   =     tokenizer.encode(UpperCAmelCase       )
							_UpperCAmelCase							   =     rust_tokenizer.encode(UpperCAmelCase       )
							self.assertListEqual(UpperCAmelCase			,       UpperCAmelCase       )

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							_UpperCAmelCase							   =     BasicTokenizer()

							self.assertListEqual(tokenizer.tokenize('ah\u535A\u63A8zz'       )			,       ['ah', '\u535A', '\u63A8', 'zz']       )

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							_UpperCAmelCase							   =     BasicTokenizer(do_lower_case=UpperCAmelCase       )

							self.assertListEqual(
							    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '       )			,       ['hello', '!', 'how', 'are', 'you', '?']       )
							self.assertListEqual(tokenizer.tokenize('H\u00E9llo'       )			,       ['hello']       )

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							_UpperCAmelCase							   =     BasicTokenizer(do_lower_case=UpperCAmelCase			,       strip_accents=UpperCAmelCase       )

							self.assertListEqual(
							    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '       )			,       ['hällo', '!', 'how', 'are', 'you', '?']       )
							self.assertListEqual(tokenizer.tokenize('H\u00E9llo'       )			,       ['h\u00E9llo']       )

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							_UpperCAmelCase							   =     BasicTokenizer(do_lower_case=UpperCAmelCase			,       strip_accents=UpperCAmelCase       )

							self.assertListEqual(
							    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '       )			,       ['hallo', '!', 'how', 'are', 'you', '?']       )
							self.assertListEqual(tokenizer.tokenize('H\u00E9llo'       )			,       ['hello']       )

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							_UpperCAmelCase							   =     BasicTokenizer(do_lower_case=UpperCAmelCase       )

							self.assertListEqual(
							    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '       )			,       ['hallo', '!', 'how', 'are', 'you', '?']       )
							self.assertListEqual(tokenizer.tokenize('H\u00E9llo'       )			,       ['hello']       )

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							_UpperCAmelCase							   =     BasicTokenizer(do_lower_case=UpperCAmelCase       )

							self.assertListEqual(
							    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '       )			,       ['HeLLo', '!', 'how', 'Are', 'yoU', '?']       )

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							_UpperCAmelCase							   =     BasicTokenizer(do_lower_case=UpperCAmelCase			,       strip_accents=UpperCAmelCase       )

							self.assertListEqual(
							    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '       )			,       ['HäLLo', '!', 'how', 'Are', 'yoU', '?']       )

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							_UpperCAmelCase							   =     BasicTokenizer(do_lower_case=UpperCAmelCase			,       strip_accents=UpperCAmelCase       )

							self.assertListEqual(
							    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '       )			,       ['HaLLo', '!', 'how', 'Are', 'yoU', '?']       )

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							_UpperCAmelCase							   =     BasicTokenizer(do_lower_case=UpperCAmelCase			,       never_split=['[UNK]']       )

							self.assertListEqual(
							    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU? [UNK]'       )			,       ['HeLLo', '!', 'how', 'Are', 'yoU', '?', '[UNK]']       )

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							_UpperCAmelCase							   =     ['[UNK]', '[CLS]', '[SEP]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing']

							_UpperCAmelCase							   =     {}
							for i, token in enumerate(UpperCAmelCase       ):
													_UpperCAmelCase							   =     i
							_UpperCAmelCase							   =     WordpieceTokenizer(vocab=UpperCAmelCase			,       unk_token='[UNK]'       )

							self.assertListEqual(tokenizer.tokenize(''       )			,       []       )

							self.assertListEqual(tokenizer.tokenize('unwanted running'       )			,       ['un', '##want', '##ed', 'runn', '##ing']       )

							self.assertListEqual(tokenizer.tokenize('unwantedX running'       )			,       ['[UNK]', 'runn', '##ing']       )

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							self.assertTrue(_is_whitespace(' '       )       )
							self.assertTrue(_is_whitespace('\t'       )       )
							self.assertTrue(_is_whitespace('\r'       )       )
							self.assertTrue(_is_whitespace('\n'       )       )
							self.assertTrue(_is_whitespace('\u00A0'       )       )

							self.assertFalse(_is_whitespace('A'       )       )
							self.assertFalse(_is_whitespace('-'       )       )

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							self.assertTrue(_is_control('\u0005'       )       )

							self.assertFalse(_is_control('A'       )       )
							self.assertFalse(_is_control(' '       )       )
							self.assertFalse(_is_control('\t'       )       )
							self.assertFalse(_is_control('\r'       )       )

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							self.assertTrue(_is_punctuation('-'       )       )
							self.assertTrue(_is_punctuation('$'       )       )
							self.assertTrue(_is_punctuation('`'       )       )
							self.assertTrue(_is_punctuation('.'       )       )

							self.assertFalse(_is_punctuation('A'       )       )
							self.assertFalse(_is_punctuation(' '       )       )

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							_UpperCAmelCase							   =     self.get_tokenizer()
							_UpperCAmelCase							   =     self.get_rust_tokenizer()

							# Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
							self.assertListEqual([tokenizer.tokenize(UpperCAmelCase       ) for t in ['Test', '\xad', 'test']]			,       [['[UNK]'], [], ['[UNK]']]       )

							self.assertListEqual(
							    [rust_tokenizer.tokenize(UpperCAmelCase       ) for t in ['Test', '\xad', 'test']]			,       [['[UNK]'], [], ['[UNK]']]       )

	@slow
	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							_UpperCAmelCase							   =     self.tokenizer_class.from_pretrained('google/electra-base-discriminator'       )

							_UpperCAmelCase							   =     tokenizer.encode('sequence builders'			,       add_special_tokens=UpperCAmelCase       )
							_UpperCAmelCase							   =     tokenizer.encode('multi-sequence build'			,       add_special_tokens=UpperCAmelCase       )

							_UpperCAmelCase							   =     tokenizer.build_inputs_with_special_tokens(UpperCAmelCase       )
							_UpperCAmelCase							   =     tokenizer.build_inputs_with_special_tokens(UpperCAmelCase			,       UpperCAmelCase       )

							assert encoded_sentence == [101] + text + [102]
							assert encoded_pair == [101] + text + [102] + text_a + [102]

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
													with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""       ):
																			_UpperCAmelCase							   =     self.rust_tokenizer_class.from_pretrained(UpperCAmelCase			,       **UpperCAmelCase       )

																			_UpperCAmelCase							   =     F"""A, naïve {tokenizer_r.mask_token} AllenNLP sentence."""
																			_UpperCAmelCase							   =     tokenizer_r.encode_plus(
																			    UpperCAmelCase			,       return_attention_mask=UpperCAmelCase			,       return_token_type_ids=UpperCAmelCase			,       return_offsets_mapping=UpperCAmelCase			,       add_special_tokens=UpperCAmelCase			,       )

																			_UpperCAmelCase							   =     tokenizer_r.do_lower_case if hasattr(UpperCAmelCase			,       'do_lower_case'       ) else False
																			_UpperCAmelCase							   =     (
																			    [
																			        ((0, 0), tokenizer_r.cls_token),
																			        ((0, 1), 'A'),
																			        ((1, 2), ','),
																			        ((3, 5), 'na'),
																			        ((5, 6), '##ï'),
																			        ((6, 8), '##ve'),
																			        ((9, 15), tokenizer_r.mask_token),
																			        ((16, 21), 'Allen'),
																			        ((21, 23), '##NL'),
																			        ((23, 24), '##P'),
																			        ((25, 33), 'sentence'),
																			        ((33, 34), '.'),
																			        ((0, 0), tokenizer_r.sep_token),
																			    ]
																			    if not do_lower_case
																			    else [
																			        ((0, 0), tokenizer_r.cls_token),
																			        ((0, 1), 'a'),
																			        ((1, 2), ','),
																			        ((3, 8), 'naive'),
																			        ((9, 15), tokenizer_r.mask_token),
																			        ((16, 21), 'allen'),
																			        ((21, 23), '##nl'),
																			        ((23, 24), '##p'),
																			        ((25, 33), 'sentence'),
																			        ((33, 34), '.'),
																			        ((0, 0), tokenizer_r.sep_token),
																			    ]
																			)

																			self.assertEqual(
																			    [e[1] for e in expected_results]			,       tokenizer_r.convert_ids_to_tokens(tokens['input_ids']       )       )
																			self.assertEqual([e[0] for e in expected_results]			,       tokens['offset_mapping']       )

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							_UpperCAmelCase							   =     ['的', '人', '有']
							_UpperCAmelCase							   =     ''.join(UpperCAmelCase       )
							for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
													with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""       ):
																			_UpperCAmelCase							   =     True
																			_UpperCAmelCase							   =     self.tokenizer_class.from_pretrained(UpperCAmelCase			,       **UpperCAmelCase       )
																			_UpperCAmelCase							   =     self.rust_tokenizer_class.from_pretrained(UpperCAmelCase			,       **UpperCAmelCase       )

																			_UpperCAmelCase							   =     tokenizer_p.encode(UpperCAmelCase			,       add_special_tokens=UpperCAmelCase       )
																			_UpperCAmelCase							   =     tokenizer_r.encode(UpperCAmelCase			,       add_special_tokens=UpperCAmelCase       )

																			_UpperCAmelCase							   =     tokenizer_r.convert_ids_to_tokens(UpperCAmelCase       )
																			_UpperCAmelCase							   =     tokenizer_p.convert_ids_to_tokens(UpperCAmelCase       )

																			# it is expected that each Chinese character is not preceded by "##"
																			self.assertListEqual(UpperCAmelCase			,       UpperCAmelCase       )
																			self.assertListEqual(UpperCAmelCase			,       UpperCAmelCase       )

																			_UpperCAmelCase							   =     False
																			_UpperCAmelCase							   =     self.rust_tokenizer_class.from_pretrained(UpperCAmelCase			,       **UpperCAmelCase       )
																			_UpperCAmelCase							   =     self.tokenizer_class.from_pretrained(UpperCAmelCase			,       **UpperCAmelCase       )

																			_UpperCAmelCase							   =     tokenizer_r.encode(UpperCAmelCase			,       add_special_tokens=UpperCAmelCase       )
																			_UpperCAmelCase							   =     tokenizer_p.encode(UpperCAmelCase			,       add_special_tokens=UpperCAmelCase       )

																			_UpperCAmelCase							   =     tokenizer_r.convert_ids_to_tokens(UpperCAmelCase       )
																			_UpperCAmelCase							   =     tokenizer_p.convert_ids_to_tokens(UpperCAmelCase       )

																			# it is expected that only the first Chinese character is not preceded by "##".
																			_UpperCAmelCase							   =     [
																			    F"""##{token}""" if idx != 0 else token for idx, token in enumerate(UpperCAmelCase       )
																			]
																			self.assertListEqual(UpperCAmelCase			,       UpperCAmelCase       )
																			self.assertListEqual(UpperCAmelCase			,       UpperCAmelCase       )








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 RobertaConfig, RobertaForMaskedLM, RobertaForSequenceClassification
from transformers.models.bert.modeling_bert import (
    BertIntermediate,
    BertLayer,
    BertOutput,
    BertSelfAttention,
    BertSelfOutput,
)
from transformers.utils import logging


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


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

_a       =    '''Hello world! cécé herlolip'''


def __A       ( __lowerCAmelCase					,						__lowerCAmelCase					,						__lowerCAmelCase      )->    List[Any]:





						"""simple docstring"""



						_UpperCAmelCase							   =     FairseqRobertaModel.from_pretrained(__lowerCAmelCase      )
						roberta.eval()  # disable dropout
						_UpperCAmelCase							   =     roberta.model.encoder.sentence_encoder
						_UpperCAmelCase							   =     RobertaConfig(
						    vocab_size=roberta_sent_encoder.embed_tokens.num_embeddings					,						hidden_size=roberta.args.encoder_embed_dim					,						num_hidden_layers=roberta.args.encoder_layers					,						num_attention_heads=roberta.args.encoder_attention_heads					,						intermediate_size=roberta.args.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 BERT config:'					,						__lowerCAmelCase      )

						_UpperCAmelCase							   =     RobertaForSequenceClassification(__lowerCAmelCase      ) if classification_head else RobertaForMaskedLM(__lowerCAmelCase      )
						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.emb_layer_norm.weight
						_UpperCAmelCase							   =     roberta_sent_encoder.emb_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]

												# 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
												_UpperCAmelCase							   =     roberta_layer.self_attn_layer_norm.weight
												_UpperCAmelCase							   =     roberta_layer.self_attn_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
												_UpperCAmelCase							   =     roberta_layer.final_layer_norm.weight
												_UpperCAmelCase							   =     roberta_layer.final_layer_norm.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(__lowerCAmelCase      ).unsqueeze(0      )  # batch of size 1

						_UpperCAmelCase							   =     model(__lowerCAmelCase      )[0]
						if classification_head:
												_UpperCAmelCase							   =     roberta.model.classification_heads['mnli'](roberta.extract_features(__lowerCAmelCase      )      )
						else:
												_UpperCAmelCase							   =     roberta.model(__lowerCAmelCase      )[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(__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__":
		_a       =    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       =    parser.parse_args()
		convert_roberta_checkpoint_to_pytorch(
		    args.roberta_checkpoint_path, args.pytorch_dump_folder_path, args.classification_head
		)
