






'''simple docstring'''







import re
import string
from collections import Counter

import sacrebleu
import sacremoses
from packaging import version

import datasets


__lowerCAmelCase       		=      '\n@inproceedings{xu-etal-2016-optimizing,\n    title = {Optimizing Statistical Machine Translation for Text Simplification},\n    authors={Xu, Wei and Napoles, Courtney and Pavlick, Ellie and Chen, Quanze and Callison-Burch, Chris},\n    journal = {Transactions of the Association for Computational Linguistics},\n    volume = {4},\n    year={2016},\n    url = {https://www.aclweb.org/anthology/Q16-1029},\n    pages = {401--415\n},\n@inproceedings{post-2018-call,\n    title = \"A Call for Clarity in Reporting {BLEU} Scores\",\n    author = \"Post, Matt\",\n    booktitle = \"Proceedings of the Third Conference on Machine Translation: Research Papers\",\n    month = oct,\n    year = \"2018\",\n    address = \"Belgium, Brussels\",\n    publisher = \"Association for Computational Linguistics\",\n    url = \"https://www.aclweb.org/anthology/W18-6319\",\n    pages = \"186--191\",\n}\n'

__lowerCAmelCase       		=      '\\nWIKI_SPLIT is the combination of three metrics SARI, EXACT and SACREBLEU\nIt can be used to evaluate the quality of machine-generated texts.\n'


__lowerCAmelCase       		=      '\nCalculates sari score (between 0 and 100) given a list of source and predicted\nsentences, and a list of lists of reference sentences. It also computes the BLEU score as well as the exact match score.\nArgs:\n    sources: list of source sentences where each sentence should be a string.\n    predictions: list of predicted sentences where each sentence should be a string.\n    references: list of lists of reference sentences where each sentence should be a string.\nReturns:\n    sari: sari score\n    sacrebleu: sacrebleu score\n    exact: exact score\n\nExamples:\n    >>> sources=[\"About 95 species are currently accepted .\"]\n    >>> predictions=[\"About 95 you now get in .\"]\n    >>> references=[[\"About 95 species are currently known .\"]]\n    >>> wiki_split = datasets.load_metric(\"wiki_split\")\n    >>> results = wiki_split.compute(sources=sources, predictions=predictions, references=references)\n    >>> print(results)\n    {\'sari\': 21.805555555555557, \'sacrebleu\': 14.535768424205482, \'exact\': 0.0}\n'





def 		_UpperCAmelCase (							__A							:   Optional[int]      ):

				def remove_articles(__A							:   Any      ):
								a_		:  Dict											=      re.compile(R'''\b(a|an|the)\b'''						,		re.UNICODE      )
								return re.sub(lowerCAmelCase__						,		''' '''						,		lowerCAmelCase__      )

				def white_space_fix(__A							:   Dict      ):
								return " ".join(text.split()      )

				def remove_punc(__A							:   Dict      ):
								a_		:  Tuple											=      set(string.punctuation      )
								return "".join(ch for ch in text if ch not in exclude      )

				def lower(__A							:   str      ):
								return text.lower()

				return white_space_fix(remove_articles(remove_punc(lower(lowerCAmelCase__      )      )      )      )





def 		_UpperCAmelCase (							__A							:   Optional[int]						,		__A							:   List[Any]      ):
				return int(normalize_answer(lowerCAmelCase__      ) == normalize_answer(lowerCAmelCase__      )      )





def 		_UpperCAmelCase (							__A							:   Any						,		__A							:   List[str]      ):
				a_		:  int											=      [any(compute_exact(lowerCAmelCase__						,		lowerCAmelCase__      ) for ref in refs      ) for pred, refs in zip(lowerCAmelCase__						,		lowerCAmelCase__      )]
				return (sum(lowerCAmelCase__      ) / len(lowerCAmelCase__      )) * 1_00





def 		_UpperCAmelCase (							__A							:   List[str]						,		__A							:   Any						,		__A							:   Any						,		__A							:   int      ):
				a_		:  Tuple											=      [rgram for rgrams in rgramslist for rgram in rgrams]
				a_		:  int											=      Counter(lowerCAmelCase__      )

				a_		:  Optional[int]											=      Counter(lowerCAmelCase__      )
				a_		:  str											=      Counter()
				for sgram, scount in sgramcounter.items():
								a_		:  Union[str, Any]											=      scount * numref

				a_		:  Any											=      Counter(lowerCAmelCase__      )
				a_		:  str											=      Counter()
				for cgram, ccount in cgramcounter.items():
								a_		:  str											=      ccount * numref

				# KEEP
				a_		:  Union[str, Any]											=      sgramcounter_rep & cgramcounter_rep
				a_		:  List[Any]											=      keepgramcounter_rep & rgramcounter
				a_		:  Optional[int]											=      sgramcounter_rep & rgramcounter

				a_		:  Union[str, Any]											=      0
				a_		:  Tuple											=      0
				for keepgram in keepgramcountergood_rep:
								keeptmpscorea += keepgramcountergood_rep[keepgram] / keepgramcounter_rep[keepgram]
								# Fix an alleged bug [2] in the keep score computation.
								# keeptmpscore2 += keepgramcountergood_rep[keepgram] / keepgramcounterall_rep[keepgram]
								keeptmpscorea += keepgramcountergood_rep[keepgram]
				# Define 0/0=1 instead of 0 to give higher scores for predictions that match
				#      a target exactly.
				a_		:  Any											=      1
				a_		:  Union[str, Any]											=      1
				if len(lowerCAmelCase__      ) > 0:
								a_		:  Optional[int]											=      keeptmpscorea / len(lowerCAmelCase__      )
				if len(lowerCAmelCase__      ) > 0:
								# Fix an alleged bug [2] in the keep score computation.
								# keepscore_recall = keeptmpscore2 / len(keepgramcounterall_rep)
								a_		:  int											=      keeptmpscorea / sum(keepgramcounterall_rep.values()      )
				a_		:  Tuple											=      0
				if keepscore_precision > 0 or keepscore_recall > 0:
								a_		:  Dict											=      2 * keepscore_precision * keepscore_recall / (keepscore_precision + keepscore_recall)

				# DELETION
				a_		:  Dict											=      sgramcounter_rep - cgramcounter_rep
				a_		:  Optional[Any]											=      delgramcounter_rep - rgramcounter
				a_		:  List[str]											=      sgramcounter_rep - rgramcounter
				a_		:  Optional[Any]											=      0
				a_		:  str											=      0
				for delgram in delgramcountergood_rep:
								deltmpscorea += delgramcountergood_rep[delgram] / delgramcounter_rep[delgram]
								deltmpscorea += delgramcountergood_rep[delgram] / delgramcounterall_rep[delgram]
				# Define 0/0=1 instead of 0 to give higher scores for predictions that match
				# a target exactly.
				a_		:  str											=      1
				if len(lowerCAmelCase__      ) > 0:
								a_		:  Optional[Any]											=      deltmpscorea / len(lowerCAmelCase__      )

				# ADDITION
				a_		:  Union[str, Any]											=      set(lowerCAmelCase__      ) - set(lowerCAmelCase__      )
				a_		:  List[Any]											=      set(lowerCAmelCase__      ) & set(lowerCAmelCase__      )
				a_		:  Union[str, Any]											=      set(lowerCAmelCase__      ) - set(lowerCAmelCase__      )

				a_		:  List[Any]											=      0
				for addgram in addgramcountergood:
								addtmpscore += 1

				# Define 0/0=1 instead of 0 to give higher scores for predictions that match
				# a target exactly.
				a_		:  str											=      1
				a_		:  List[str]											=      1
				if len(lowerCAmelCase__      ) > 0:
								a_		:  Optional[Any]											=      addtmpscore / len(lowerCAmelCase__      )
				if len(lowerCAmelCase__      ) > 0:
								a_		:  Union[str, Any]											=      addtmpscore / len(lowerCAmelCase__      )
				a_		:  Optional[Any]											=      0
				if addscore_precision > 0 or addscore_recall > 0:
								a_		:  Any											=      2 * addscore_precision * addscore_recall / (addscore_precision + addscore_recall)

				return (keepscore, delscore_precision, addscore)





def 		_UpperCAmelCase (							__A							:   Optional[int]						,		__A							:   Optional[Any]						,		__A							:   List[str]      ):
				a_		:  str											=      len(lowerCAmelCase__      )

				a_		:  Any											=      ssent.split(''' '''      )
				a_		:  Optional[int]											=      csent.split(''' '''      )
				a_		:  str											=      []
				a_		:  List[str]											=      []
				a_		:  int											=      []
				a_		:  Dict											=      []
				a_		:  str											=      []
				a_		:  int											=      []

				a_		:  Any											=      []
				a_		:  List[Any]											=      []
				a_		:  Union[str, Any]											=      []
				a_		:  str											=      []
				for rsent in rsents:
								a_		:  Any											=      rsent.split(''' '''      )
								a_		:  Tuple											=      []
								a_		:  Dict											=      []
								a_		:  str											=      []
								ragramslist.append(lowerCAmelCase__      )
								for i in range(0						,		len(lowerCAmelCase__      ) - 1      ):
												if i < len(lowerCAmelCase__      ) - 1:
																a_		:  Union[str, Any]											=      ragrams[i] + ''' ''' + ragrams[i + 1]
																ragrams.append(lowerCAmelCase__      )
												if i < len(lowerCAmelCase__      ) - 2:
																a_		:  Dict											=      ragrams[i] + ''' ''' + ragrams[i + 1] + ''' ''' + ragrams[i + 2]
																ragrams.append(lowerCAmelCase__      )
												if i < len(lowerCAmelCase__      ) - 3:
																a_		:  Optional[Any]											=      ragrams[i] + ''' ''' + ragrams[i + 1] + ''' ''' + ragrams[i + 2] + ''' ''' + ragrams[i + 3]
																ragrams.append(lowerCAmelCase__      )
								ragramslist.append(lowerCAmelCase__      )
								ragramslist.append(lowerCAmelCase__      )
								ragramslist.append(lowerCAmelCase__      )

				for i in range(0						,		len(lowerCAmelCase__      ) - 1      ):
								if i < len(lowerCAmelCase__      ) - 1:
												a_		:  int											=      sagrams[i] + ''' ''' + sagrams[i + 1]
												sagrams.append(lowerCAmelCase__      )
								if i < len(lowerCAmelCase__      ) - 2:
												a_		:  List[Any]											=      sagrams[i] + ''' ''' + sagrams[i + 1] + ''' ''' + sagrams[i + 2]
												sagrams.append(lowerCAmelCase__      )
								if i < len(lowerCAmelCase__      ) - 3:
												a_		:  Union[str, Any]											=      sagrams[i] + ''' ''' + sagrams[i + 1] + ''' ''' + sagrams[i + 2] + ''' ''' + sagrams[i + 3]
												sagrams.append(lowerCAmelCase__      )

				for i in range(0						,		len(lowerCAmelCase__      ) - 1      ):
								if i < len(lowerCAmelCase__      ) - 1:
												a_		:  List[str]											=      cagrams[i] + ''' ''' + cagrams[i + 1]
												cagrams.append(lowerCAmelCase__      )
								if i < len(lowerCAmelCase__      ) - 2:
												a_		:  int											=      cagrams[i] + ''' ''' + cagrams[i + 1] + ''' ''' + cagrams[i + 2]
												cagrams.append(lowerCAmelCase__      )
								if i < len(lowerCAmelCase__      ) - 3:
												a_		:  str											=      cagrams[i] + ''' ''' + cagrams[i + 1] + ''' ''' + cagrams[i + 2] + ''' ''' + cagrams[i + 3]
												cagrams.append(lowerCAmelCase__      )

				((a_)				,			(a_)				,			(a_))		:  Any											=      SARIngram(lowerCAmelCase__						,		lowerCAmelCase__						,		lowerCAmelCase__						,		lowerCAmelCase__      )
				((a_)				,			(a_)				,			(a_))		:  Union[str, Any]											=      SARIngram(lowerCAmelCase__						,		lowerCAmelCase__						,		lowerCAmelCase__						,		lowerCAmelCase__      )
				((a_)				,			(a_)				,			(a_))		:  str											=      SARIngram(lowerCAmelCase__						,		lowerCAmelCase__						,		lowerCAmelCase__						,		lowerCAmelCase__      )
				((a_)				,			(a_)				,			(a_))		:  str											=      SARIngram(lowerCAmelCase__						,		lowerCAmelCase__						,		lowerCAmelCase__						,		lowerCAmelCase__      )
				a_		:  Dict											=      sum([keepascore, keepascore, keepascore, keepascore]      ) / 4
				a_		:  Union[str, Any]											=      sum([delascore, delascore, delascore, delascore]      ) / 4
				a_		:  List[Any]											=      sum([addascore, addascore, addascore, addascore]      ) / 4
				a_		:  Optional[Any]											=      (avgkeepscore + avgdelscore + avgaddscore) / 3
				return finalscore





def 		_UpperCAmelCase (							__A							:   Optional[int]						,		__A							:   int = True						,		__A							:   Union[str, Any] = "13a"						,		__A							:   Tuple = True      ):
				# Normalization is requried for the ASSET dataset (one of the primary
				# datasets in sentence simplification) to allow using space
				# to split the sentence. Even though Wiki-Auto and TURK datasets,
				# do not require normalization, we do it for consistency.
				# Code adapted from the EASSE library [1] written by the authors of the ASSET dataset.
				# [1] https://github.com/feralvam/easse/blob/580bba7e1378fc8289c663f864e0487188fe8067/easse/utils/preprocessing.py#L7

				if lowercase:
								a_		:  Union[str, Any]											=      sentence.lower()

				if tokenizer in ["13a", "intl"]:
								if version.parse(sacrebleu.__version__      ).major >= 2:
												a_		:  Optional[Any]											=      sacrebleu.metrics.bleu._get_tokenizer(lowerCAmelCase__      )()(lowerCAmelCase__      )
								else:
												a_		:  List[Any]											=      sacrebleu.TOKENIZERS[tokenizer]()(lowerCAmelCase__      )
				elif tokenizer == "moses":
								a_		:  List[str]											=      sacremoses.MosesTokenizer().tokenize(lowerCAmelCase__						,		return_str=lowerCAmelCase__						,		escape=lowerCAmelCase__      )
				elif tokenizer == "penn":
								a_		:  int											=      sacremoses.MosesTokenizer().penn_tokenize(lowerCAmelCase__						,		return_str=lowerCAmelCase__      )
				else:
								a_		:  str											=      sentence

				if not return_str:
								a_		:  Dict											=      normalized_sent.split()

				return normalized_sent





def 		_UpperCAmelCase (							__A							:   int						,		__A							:   int						,		__A							:   Optional[Any]      ):
				if not (len(lowerCAmelCase__      ) == len(lowerCAmelCase__      ) == len(lowerCAmelCase__      )):
								raise ValueError('''Sources length must match predictions and references lengths.'''      )
				a_		:  Tuple											=      0
				for src, pred, refs in zip(lowerCAmelCase__						,		lowerCAmelCase__						,		lowerCAmelCase__      ):
								sari_score += SARIsent(normalize(lowerCAmelCase__      )						,		normalize(lowerCAmelCase__      )						,		[normalize(lowerCAmelCase__      ) for sent in refs]      )
				a_		:  List[str]											=      sari_score / len(lowerCAmelCase__      )
				return 1_00 * sari_score





def 		_UpperCAmelCase (							__A							:   Optional[int]						,		__A							:   Union[str, Any]						,		__A							:   List[Any]="exp"						,		__A							:   List[Any]=None						,		__A							:   List[str]=False						,		__A							:   Tuple=False						,		__A							:   Any=False						,		):
				a_		:  Union[str, Any]											=      len(references[0]      )
				if any(len(lowerCAmelCase__      ) != references_per_prediction for refs in references      ):
								raise ValueError('''Sacrebleu requires the same number of references for each prediction'''      )
				a_		:  str											=      [[refs[i] for refs in references] for i in range(lowerCAmelCase__      )]
				a_		:  List[str]											=      sacrebleu.corpus_bleu(
				    lowerCAmelCase__						,		lowerCAmelCase__						,		smooth_method=lowerCAmelCase__						,		smooth_value=lowerCAmelCase__						,		force=lowerCAmelCase__						,		lowercase=lowerCAmelCase__						,		use_effective_order=lowerCAmelCase__						,		)
				return output.score





@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION	,   _KWARGS_DESCRIPTION       )
class 	SCREAMING_SNAKE_CASE					(					datasets.Metric       ):






			def 			SCREAMING_SNAKE_CASE      ( self      :			List[Any]					)			->			str:
							return datasets.MetricInfo(
							    description=_DESCRIPTION  ,						citation=_CITATION  ,						inputs_description=_KWARGS_DESCRIPTION  ,						features=datasets.Features(
							        {
							            '''predictions''': datasets.Value('''string'''  ,						id='''sequence'''					),
							            '''references''': datasets.Sequence(datasets.Value('''string'''  ,						id='''sequence'''					)  ,						id='''references'''					),
							        }					)  ,						codebase_urls=[
							        '''https://github.com/huggingface/transformers/blob/master/src/transformers/data/metrics/squad_metrics.py''',
							        '''https://github.com/cocoxu/simplification/blob/master/SARI.py''',
							        '''https://github.com/tensorflow/tensor2tensor/blob/master/tensor2tensor/utils/sari_hook.py''',
							        '''https://github.com/mjpost/sacreBLEU''',
							    ]  ,						reference_urls=[
							        '''https://www.aclweb.org/anthology/Q16-1029.pdf''',
							        '''https://github.com/mjpost/sacreBLEU''',
							        '''https://en.wikipedia.org/wiki/BLEU''',
							        '''https://towardsdatascience.com/evaluating-text-output-in-nlp-bleu-at-your-own-risk-e8609665a213''',
							    ]  ,						)







			def 			SCREAMING_SNAKE_CASE      ( self      :			Optional[Any]  ,						__SCREAMING_SNAKE_CASE      :			Optional[Any]  ,						__SCREAMING_SNAKE_CASE      :			List[Any]  ,						__SCREAMING_SNAKE_CASE      :			int					)			->			Dict:
							a_		:  Optional[int]											=      {}
							result.update({'''sari''': compute_sari(sources=_UpperCAmelCase  ,						predictions=_UpperCAmelCase  ,						references=_UpperCAmelCase					)}					)
							result.update({'''sacrebleu''': compute_sacrebleu(predictions=_UpperCAmelCase  ,						references=_UpperCAmelCase					)}					)
							result.update({'''exact''': compute_em(predictions=_UpperCAmelCase  ,						references=_UpperCAmelCase					)}					)
							return result












'''simple docstring'''







import argparse

from torch import nn

# transformers_old should correspond to branch `save_old_prophetnet_model_structure` here
# original prophetnet_checkpoints are saved under `patrickvonplaten/..._old` respectively
from transformers_old.modeling_prophetnet import (
    ProphetNetForConditionalGeneration as ProphetNetForConditionalGenerationOld,
)
from transformers_old.modeling_xlm_prophetnet import (
    XLMProphetNetForConditionalGeneration as XLMProphetNetForConditionalGenerationOld,
)

from transformers import ProphetNetForConditionalGeneration, XLMProphetNetForConditionalGeneration, logging


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





def 		_UpperCAmelCase   (							__A							:   str						,		__A							:   str      ):
				if "xprophetnet" in prophetnet_checkpoint_path:
								a_		:  Tuple											=      XLMProphetNetForConditionalGenerationOld.from_pretrained(__A      )
								a_				,			a_		:  Optional[Any]											=      XLMProphetNetForConditionalGeneration.from_pretrained(
								    __A						,		output_loading_info=__A      )
				else:
								a_		:  List[Any]											=      ProphetNetForConditionalGenerationOld.from_pretrained(__A      )
								a_				,			a_		:  Any											=      ProphetNetForConditionalGeneration.from_pretrained(
								    __A						,		output_loading_info=__A      )

				a_		:  str											=      ['''key_proj''', '''value_proj''', '''query_proj''']

				a_		:  Tuple											=      {
				    '''self_attn''': '''ngram_self_attn''',
				    '''cross_attn''': '''encoder_attn''',
				    '''cross_attn_layer_norm''': '''encoder_attn_layer_norm''',
				    '''feed_forward_layer_norm''': '''final_layer_norm''',
				    '''feed_forward''': '''''',
				    '''intermediate''': '''fc1''',
				    '''output''': '''fc2''',
				    '''key_proj''': '''k_proj''',
				    '''query_proj''': '''q_proj''',
				    '''value_proj''': '''v_proj''',
				    '''word_embeddings''': '''embed_tokens''',
				    '''embeddings_layer_norm''': '''emb_layer_norm''',
				    '''relative_pos_embeddings''': '''relative_linear''',
				    '''ngram_embeddings''': '''ngram_input_embed''',
				    '''position_embeddings''': '''embed_positions''',
				}

				for key in loading_info["missing_keys"]:
								a_		:  List[str]											=      key.split('''.'''      )

								if attributes[0] == "lm_head":
												a_		:  List[str]											=      prophet
												a_		:  Dict											=      prophet_old
								else:
												a_		:  str											=      prophet.prophetnet
												a_		:  int											=      prophet_old.model

								a_		:  str											=      False
								for attribute in attributes:
												if attribute in mapping:
																a_		:  Dict											=      mapping[attribute]
																if not hasattr(__A						,		__A      ) and len(__A      ) > 0:
																				a_		:  List[str]											=      attribute
												elif hasattr(__A						,		__A      ):
																a_		:  Union[str, Any]											=      attribute

												if attribute == "weight":
																assert old_model.weight.shape == model.weight.shape, "Shapes have to match!"
																a_		:  Tuple											=      old_model.weight
																logger.info(f'{attribute} is initialized.'      )
																a_		:  Union[str, Any]											=      True
																break
												elif attribute == "bias":
																assert old_model.bias.shape == model.bias.shape, "Shapes have to match!"
																a_		:  Union[str, Any]											=      old_model.bias
																logger.info(f'{attribute} is initialized'      )
																a_		:  Dict											=      True
																break
												elif attribute in special_keys and hasattr(__A						,		'''in_proj_weight'''      ):
																a_		:  Tuple											=      old_model.in_proj_weight.shape[0] // 3
																a_		:  Any											=      getattr(__A						,		__A      )
																param.weight.shape == old_model.in_proj_weight[:embed_dim, :].shape, "Shapes have to match"
																param.bias.shape == old_model.in_proj_bias[:embed_dim].shape, "Shapes have to match"
																if attribute == "query_proj":
																				a_		:  Union[str, Any]											=      nn.Parameter(old_model.in_proj_weight[:embed_dim, :]      )
																				a_		:  Optional[Any]											=      nn.Parameter(old_model.in_proj_bias[:embed_dim]      )

																elif attribute == "key_proj":
																				a_		:  List[Any]											=      nn.Parameter(old_model.in_proj_weight[embed_dim : 2 * embed_dim, :]      )
																				a_		:  Optional[int]											=      nn.Parameter(old_model.in_proj_bias[embed_dim : 2 * embed_dim]      )
																elif attribute == "value_proj":
																				a_		:  Tuple											=      nn.Parameter(old_model.in_proj_weight[2 * embed_dim :, :]      )
																				a_		:  Any											=      nn.Parameter(old_model.in_proj_bias[2 * embed_dim :]      )
																a_		:  Dict											=      True
																break
												elif attribute == "position_embeddings":
																assert (
																    model.position_embeddings.weight.shape[-1] == old_model.embed_positions.weight.shape[-1]
																), "Hidden size has to match"
																assert model.position_embeddings.weight.shape[0] == 5_12, "We want 512 position_embeddings."
																a_		:  Union[str, Any]											=      nn.Parameter(old_model.embed_positions.weight[:5_12, :]      )
																a_		:  Optional[Any]											=      True
																break

												if attribute.isdigit():
																a_		:  Union[str, Any]											=      model[int(__A      )]
																a_		:  str											=      old_model[int(__A      )]
												else:
																a_		:  Tuple											=      getattr(__A						,		__A      )

																if old_attribute == "":
																				a_		:  List[str]											=      old_model
																else:
																				if not hasattr(__A						,		__A      ):
																								raise ValueError(f'{old_model} does not have {old_attribute}'      )
																				a_		:  Optional[Any]											=      getattr(__A						,		__A      )

								if not is_key_init:
												raise ValueError(f'{key} was not correctly initialized!'      )

				print(f'Saving model to {pytorch_dump_folder_path}'      )
				prophet.save_pretrained(__A      )


if __name__ == "__main__":
		__lowerCAmelCase       		=      argparse.ArgumentParser()
		# Required parameters
		parser.add_argument(
		    '--prophetnet_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.'
		)
		__lowerCAmelCase       		=      parser.parse_args()
		convert_prophetnet_checkpoint_to_pytorch(args.prophetnet_checkpoint_path, args.pytorch_dump_folder_path)




