





import sacrebleu as scb
from packaging import version

import datasets


_lowerCamelCase							=     '\\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							=     '\\nSacreBLEU provides hassle-free computation of shareable, comparable, and reproducible BLEU scores.\nInspired by Rico Sennrich\'s `multi-bleu-detok.perl`, it produces the official WMT scores but works with plain text.\nIt also knows all the standard test sets and handles downloading, processing, and tokenization for you.\n\nSee the [README.md] file at https://github.com/mjpost/sacreBLEU for more information.\n'

_lowerCamelCase							=     '\nProduces BLEU scores along with its sufficient statistics\nfrom a source against one or more references.\n\nArgs:\n    predictions (`list` of `str`): list of translations to score. Each translation should be tokenized into a list of tokens.\n    references (`list` of `list` of `str`): A list of lists of references. The contents of the first sub-list are the references for the first prediction, the contents of the second sub-list are for the second prediction, etc. Note that there must be the same number of references for each prediction (i.e. all sub-lists must be of the same length).\n    smooth_method (`str`): The smoothing method to use, defaults to `\'exp\'`. Possible values are:\n        - `\'none\'`: no smoothing\n        - `\'floor\'`: increment zero counts\n        - `\'add-k\'`: increment num/denom by k for n>1\n        - `\'exp\'`: exponential decay\n    smooth_value (`float`): The smoothing value. Only valid when `smooth_method=\'floor\'` (in which case `smooth_value` defaults to `0.1`) or `smooth_method=\'add-k\'` (in which case `smooth_value` defaults to `1`).\n    tokenize (`str`): Tokenization method to use for BLEU. If not provided, defaults to `\'zh\'` for Chinese, `\'ja-mecab\'` for Japanese and `\'13a\'` (mteval) otherwise. Possible values are:\n        - `\'none\'`: No tokenization.\n        - `\'zh\'`: Chinese tokenization.\n        - `\'13a\'`: mimics the `mteval-v13a` script from Moses.\n        - `\'intl\'`: International tokenization, mimics the `mteval-v14` script from Moses\n        - `\'char\'`: Language-agnostic character-level tokenization.\n        - `\'ja-mecab\'`: Japanese tokenization. Uses the [MeCab tokenizer](https://pypi.org/project/mecab-python3).\n    lowercase (`bool`): If `True`, lowercases the input, enabling case-insensitivity. Defaults to `False`.\n    force (`bool`): If `True`, insists that your tokenized input is actually detokenized. Defaults to `False`.\n    use_effective_order (`bool`): If `True`, stops including n-gram orders for which precision is 0. This should be `True`, if sentence-level BLEU will be computed. Defaults to `False`.\n\nReturns:\n    \'score\': BLEU score,\n    \'counts\': Counts,\n    \'totals\': Totals,\n    \'precisions\': Precisions,\n    \'bp\': Brevity penalty,\n    \'sys_len\': predictions length,\n    \'ref_len\': reference length,\n\nExamples:\n\n    Example 1:\n        >>> predictions = ["hello there general kenobi", "foo bar foobar"]\n        >>> references = [["hello there general kenobi", "hello there !"], ["foo bar foobar", "foo bar foobar"]]\n        >>> sacrebleu = datasets.load_metric("sacrebleu")\n        >>> results = sacrebleu.compute(predictions=predictions, references=references)\n        >>> print(list(results.keys()))\n        [\'score\', \'counts\', \'totals\', \'precisions\', \'bp\', \'sys_len\', \'ref_len\']\n        >>> print(round(results["score"], 1))\n        100.0\n\n    Example 2:\n        >>> predictions = ["hello there general kenobi",\n        ...                 "on our way to ankh morpork"]\n        >>> references = [["hello there general kenobi", "hello there !"],\n        ...                 ["goodbye ankh morpork", "ankh morpork"]]\n        >>> sacrebleu = datasets.load_metric("sacrebleu")\n        >>> results = sacrebleu.compute(predictions=predictions,\n        ...                             references=references)\n        >>> print(list(results.keys()))\n        [\'score\', \'counts\', \'totals\', \'precisions\', \'bp\', \'sys_len\', \'ref_len\']\n        >>> print(round(results["score"], 1))\n        39.8\n'




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


							def        _snake_case					(							self      :str						)				->				List[str]:



									"""simple docstring"""



									if version.parse(scb.__version__						) < version.parse("""1.4.12"""						):
											raise ImportWarning(
											    """To use `sacrebleu`, the module `sacrebleu>=1.4.12` is required, and the current version of `sacrebleu` doesn't match this condition.\n"""
											    """You can install it with `pip install \"sacrebleu>=1.4.12\"`."""						)
									return datasets.MetricInfo(
									    description=_DESCRIPTION							,			citation=_CITATION							,			homepage="""https://github.com/mjpost/sacreBLEU"""							,			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/mjpost/sacreBLEU"""]							,			reference_urls=[
									        """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        _snake_case					(							self      :Any							,			__A      :int							,			__A      :List[Any]							,			__A      :str="exp"							,			__A      :Dict=None							,			__A      :Tuple=False							,			__A      :Union[str, Any]=False							,			__A      :List[Any]=None							,			__A      :str=False							,			)				->				Optional[Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								= len(references[0]						)
									if any(len(__A						) != references_per_prediction for refs in references						):
											raise ValueError("""Sacrebleu requires the same number of references for each prediction"""						)
									SCREAMING_SNAKE_CASE__								= [[refs[i] for refs in references] for i in range(__A						)]
									SCREAMING_SNAKE_CASE__								= scb.corpus_bleu(
									    __A							,			__A							,			smooth_method=__A							,			smooth_value=__A							,			force=__A							,			lowercase=__A							,			use_effective_order=__A							,			**({"""tokenize""": tokenize} if tokenize else {})							,			)
									SCREAMING_SNAKE_CASE__								= {
									    """score""": output.score,
									    """counts""": output.counts,
									    """totals""": output.totals,
									    """precisions""": output.precisions,
									    """bp""": output.bp,
									    """sys_len""": output.sys_len,
									    """ref_len""": output.ref_len,
									}
									return output_dict






import argparse

import torch

from transformers import ImageGPTConfig, ImageGPTForCausalLM, load_tf_weights_in_imagegpt
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()






def 			SCREAMING_SNAKE_CASE__							(    UpperCamelCase__:							Any   ,				UpperCamelCase__:							List[Any]   ,				UpperCamelCase__:							Union[str, Any]      ):
		# Construct configuration depending on size
		SCREAMING_SNAKE_CASE__								= {"""small""": (512, 8, 24), """medium""": (1_024, 8, 36), """large""": (1_536, 16, 48)}
		SCREAMING_SNAKE_CASE__		,  SCREAMING_SNAKE_CASE__		,  SCREAMING_SNAKE_CASE__								= MODELS[model_size]  # set model hyperparameters
		SCREAMING_SNAKE_CASE__								= ImageGPTConfig(n_embd=UpperCamelCase__   ,				n_layer=UpperCamelCase__   ,				n_head=UpperCamelCase__      )
		SCREAMING_SNAKE_CASE__								= ImageGPTForCausalLM(UpperCamelCase__      )

		# Load weights from numpy
		load_tf_weights_in_imagegpt(UpperCamelCase__   ,				UpperCamelCase__   ,				UpperCamelCase__      )

		# Save pytorch-model
		SCREAMING_SNAKE_CASE__								= pytorch_dump_folder_path + """/""" + WEIGHTS_NAME
		SCREAMING_SNAKE_CASE__								= pytorch_dump_folder_path + """/""" + CONFIG_NAME
		print(f'''Save PyTorch model to {pytorch_weights_dump_path}'''      )
		torch.save(model.state_dict()   ,				UpperCamelCase__      )
		print(f'''Save configuration file to {pytorch_config_dump_path}'''      )
		with open(UpperCamelCase__   ,				"""w"""   ,				encoding="""utf-8"""      ) as f:
				f.write(config.to_json_string()      )


if __name__ == "__main__":
	_lowerCamelCase							=     argparse.ArgumentParser()
	# Required parameters
	parser.add_argument(
	    '--imagegpt_checkpoint_path',
	    default=None,
	    type=str,
	    required=True,
	    help='Path to the TensorFlow checkpoint path.',
	)
	parser.add_argument(
	    '--model_size',
	    default=None,
	    type=str,
	    required=True,
	    help='Size of the model (can be either \'small\', \'medium\' or \'large\').',
	)
	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_imagegpt_checkpoint_to_pytorch(
	    args.imagegpt_checkpoint_path, args.model_size, args.pytorch_dump_folder_path
	)