

import numpy as np
from nltk.translate import meteor_score

import datasets
from datasets.config import importlib_metadata, version


lowerCAmelCase__	   = version.parse(importlib_metadata.version("""nltk"""))
if NLTK_VERSION >= version.Version("""3.6.4"""):
	from nltk import word_tokenize


lowerCAmelCase__	   = """\
@inproceedings{banarjee2005,
  title     = {{METEOR}: An Automatic Metric for {MT} Evaluation with Improved Correlation with Human Judgments},
  author    = {Banerjee, Satanjeev  and Lavie, Alon},
  booktitle = {Proceedings of the {ACL} Workshop on Intrinsic and Extrinsic Evaluation Measures for Machine Translation and/or Summarization},
  month     = jun,
  year      = {2005},
  address   = {Ann Arbor, Michigan},
  publisher = {Association for Computational Linguistics},
  url       = {https://www.aclweb.org/anthology/W05-0909},
  pages     = {65--72},
}
"""

lowerCAmelCase__	   = """\
METEOR, an automatic metric for machine translation evaluation
that is based on a generalized concept of unigram matching between the
machine-produced translation and human-produced reference translations.
Unigrams can be matched based on their surface forms, stemmed forms,
and meanings; furthermore, METEOR can be easily extended to include more
advanced matching strategies. Once all generalized unigram matches
between the two strings have been found, METEOR computes a score for
this matching using a combination of unigram-precision, unigram-recall, and
a measure of fragmentation that is designed to directly capture how
well-ordered the matched words in the machine translation are in relation
to the reference.

METEOR gets an R correlation value of 0.347 with human evaluation on the Arabic
data and 0.331 on the Chinese data. This is shown to be an improvement on
using simply unigram-precision, unigram-recall and their harmonic F1
combination.
"""

lowerCAmelCase__	   = """
Computes METEOR score of translated segments against one or more references.
Args:
    predictions: list of predictions to score. Each prediction
        should be a string with tokens separated by spaces.
    references: list of reference for each prediction. Each
        reference should be a string with tokens separated by spaces.
    alpha: Parameter for controlling relative weights of precision and recall. default: 0.9
    beta: Parameter for controlling shape of penalty as a function of fragmentation. default: 3
    gamma: Relative weight assigned to fragmentation penalty. default: 0.5
Returns:
    'meteor': meteor score.
Examples:

    >>> meteor = datasets.load_metric('meteor')
    >>> predictions = [\"It is a guide to action which ensures that the military always obeys the commands of the party\"]
    >>> references = [\"It is a guide to action that ensures that the military will forever heed Party commands\"]
    >>> results = meteor.compute(predictions=predictions, references=references)
    >>> print(round(results[\"meteor\"], 4))
    0.6944
"""

@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION							,	_KWARGS_DESCRIPTION			)
class 					a__						(					datasets.Metric			):
			"""simple docstring"""







			def      UpperCamelCase		(    self       )  ->						Tuple:
							'''simple docstring'''






							return datasets.MetricInfo(
							    description=_DESCRIPTION      ,      citation=_CITATION      ,      inputs_description=_KWARGS_DESCRIPTION      ,      features=datasets.Features(
							        {
							            "predictions": datasets.Value("string"      ,      id="sequence"       ),
							            "references": datasets.Value("string"      ,      id="sequence"       ),
							        }       )      ,      codebase_urls=["https://github.com/nltk/nltk/blob/develop/nltk/translate/meteor_score.py"]      ,      reference_urls=[
							        "https://www.nltk.org/api/nltk.translate.html#module-nltk.translate.meteor_score",
							        "https://en.wikipedia.org/wiki/METEOR",
							    ]      ,      )


			def      UpperCamelCase		(    self      ,      lowercase       )  ->						int:
							'''simple docstring'''






							import nltk

							nltk.download("wordnet"       )
							if NLTK_VERSION >= version.Version("3.6.5"       ):
											nltk.download("punkt"       )
							if NLTK_VERSION >= version.Version("3.6.6"       ):
											nltk.download("omw-1.4"       )


			def      UpperCamelCase		(    self      ,      lowercase      ,      lowercase      ,      lowercase=0.9      ,      lowercase=3      ,      lowercase=0.5       )  ->						Dict:
							'''simple docstring'''






							if NLTK_VERSION >= version.Version("3.6.5"       ):
											A__        =			[
											    meteor_score.single_meteor_score(
											        word_tokenize(lowercase       )      ,      word_tokenize(lowercase       )      ,      alpha=lowercase      ,      beta=lowercase      ,      gamma=lowercase       )
											    for ref, pred in zip(lowercase      ,      lowercase       )
											]
							else:
											A__        =			[
											    meteor_score.single_meteor_score(lowercase      ,      lowercase      ,      alpha=lowercase      ,      beta=lowercase      ,      gamma=lowercase       )
											    for ref, pred in zip(lowercase      ,      lowercase       )
											]

							return {"meteor": np.mean(lowercase       )}




from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand



def 					lowerCAmelCase__							(	SCREAMING_SNAKE_CASE_:							Namespace      )			->      Tuple:




				'''simple docstring'''





				return ConvertCommand(
				    args.model_type	,       args.tf_checkpoint	,       args.pytorch_dump_output	,       args.config	,       args.finetuning_task_name      )


lowerCAmelCase__	   = """
transformers can only be used from the commandline to convert TensorFlow models in PyTorch, In that case, it requires
TensorFlow to be installed. Please see https://www.tensorflow.org/install/ for installation instructions.
"""





class 					a__						(					snake_case			):
			"""simple docstring"""







			@staticmethod
			def      UpperCamelCase		(    lowercase       )  ->						Optional[int]:
							'''simple docstring'''






							A__        =			parser.add_parser(
							    "convert"      ,      help="CLI tool to run convert model from original author checkpoints to Transformers PyTorch checkpoints."      ,      )
							train_parser.add_argument("--model_type"      ,      type=lowercase      ,      required=lowercase      ,      help="Model's type."       )
							train_parser.add_argument(
							    "--tf_checkpoint"      ,      type=lowercase      ,      required=lowercase      ,      help="TensorFlow checkpoint path or folder."       )
							train_parser.add_argument(
							    "--pytorch_dump_output"      ,      type=lowercase      ,      required=lowercase      ,      help="Path to the PyTorch saved model output."       )
							train_parser.add_argument("--config"      ,      type=lowercase      ,      default=""      ,      help="Configuration file path or folder."       )
							train_parser.add_argument(
							    "--finetuning_task_name"      ,      type=lowercase      ,      default=lowercase      ,      help="Optional fine-tuning task name if the TF model was a finetuned model."      ,      )
							train_parser.set_defaults(func=lowercase       )


			def __init__(    self      ,      lowercase      ,      lowercase      ,      lowercase      ,      lowercase      ,      lowercase      ,      *lowercase      ,      )  ->						Union[str, Any]:
							'''simple docstring'''






							A__        =			logging.get_logger("transformers-cli/converting"       )

							self._logger.info(F'Loading model {model_type}'       )
							A__        =			model_type
							A__        =			tf_checkpoint
							A__        =			pytorch_dump_output
							A__        =			config
							A__        =			finetuning_task_name


			def      UpperCamelCase		(    self       )  ->						Union[str, Any]:
							'''simple docstring'''






							if self._model_type == "albert":
											try:
															from ..models.albert.convert_albert_original_tf_checkpoint_to_pytorch import (
															    convert_tf_checkpoint_to_pytorch,
															)
											except ImportError:
															raise ImportError(lowercase       )

											convert_tf_checkpoint_to_pytorch(self._tf_checkpoint      ,      self._config      ,      self._pytorch_dump_output       )
							elif self._model_type == "bert":
											try:
															from ..models.bert.convert_bert_original_tf_checkpoint_to_pytorch import (
															    convert_tf_checkpoint_to_pytorch,
															)
											except ImportError:
															raise ImportError(lowercase       )

											convert_tf_checkpoint_to_pytorch(self._tf_checkpoint      ,      self._config      ,      self._pytorch_dump_output       )
							elif self._model_type == "funnel":
											try:
															from ..models.funnel.convert_funnel_original_tf_checkpoint_to_pytorch import (
															    convert_tf_checkpoint_to_pytorch,
															)
											except ImportError:
															raise ImportError(lowercase       )

											convert_tf_checkpoint_to_pytorch(self._tf_checkpoint      ,      self._config      ,      self._pytorch_dump_output       )
							elif self._model_type == "t5":
											try:
															from ..models.ta.convert_ta_original_tf_checkpoint_to_pytorch import convert_tf_checkpoint_to_pytorch
											except ImportError:
															raise ImportError(lowercase       )

											convert_tf_checkpoint_to_pytorch(self._tf_checkpoint      ,      self._config      ,      self._pytorch_dump_output       )
							elif self._model_type == "gpt":
											from ..models.openai.convert_openai_original_tf_checkpoint_to_pytorch import (
											    convert_openai_checkpoint_to_pytorch,
											)

											convert_openai_checkpoint_to_pytorch(self._tf_checkpoint      ,      self._config      ,      self._pytorch_dump_output       )
							elif self._model_type == "transfo_xl":
											try:
															from ..models.transfo_xl.convert_transfo_xl_original_tf_checkpoint_to_pytorch import (
															    convert_transfo_xl_checkpoint_to_pytorch,
															)
											except ImportError:
															raise ImportError(lowercase       )

											if "ckpt" in self._tf_checkpoint.lower():
															A__        =			self._tf_checkpoint
															A__        =			""
											else:
															A__        =			self._tf_checkpoint
															A__        =			""
											convert_transfo_xl_checkpoint_to_pytorch(
											    lowercase      ,      self._config      ,      self._pytorch_dump_output      ,      lowercase       )
							elif self._model_type == "gpt2":
											try:
															from ..models.gpta.convert_gpta_original_tf_checkpoint_to_pytorch import (
															    convert_gpta_checkpoint_to_pytorch,
															)
											except ImportError:
															raise ImportError(lowercase       )

											convert_gpta_checkpoint_to_pytorch(self._tf_checkpoint      ,      self._config      ,      self._pytorch_dump_output       )
							elif self._model_type == "xlnet":
											try:
															from ..models.xlnet.convert_xlnet_original_tf_checkpoint_to_pytorch import (
															    convert_xlnet_checkpoint_to_pytorch,
															)
											except ImportError:
															raise ImportError(lowercase       )

											convert_xlnet_checkpoint_to_pytorch(
											    self._tf_checkpoint      ,      self._config      ,      self._pytorch_dump_output      ,      self._finetuning_task_name       )
							elif self._model_type == "xlm":
											from ..models.xlm.convert_xlm_original_pytorch_checkpoint_to_pytorch import (
											    convert_xlm_checkpoint_to_pytorch,
											)

											convert_xlm_checkpoint_to_pytorch(self._tf_checkpoint      ,      self._pytorch_dump_output       )
							elif self._model_type == "lxmert":
											from ..models.lxmert.convert_lxmert_original_tf_checkpoint_to_pytorch import (
											    convert_lxmert_checkpoint_to_pytorch,
											)

											convert_lxmert_checkpoint_to_pytorch(self._tf_checkpoint      ,      self._pytorch_dump_output       )
							elif self._model_type == "rembert":
											from ..models.rembert.convert_rembert_tf_checkpoint_to_pytorch import (
											    convert_rembert_tf_checkpoint_to_pytorch,
											)

											convert_rembert_tf_checkpoint_to_pytorch(self._tf_checkpoint      ,      self._config      ,      self._pytorch_dump_output       )
							else:
											raise ValueError(
											    "--model_type should be selected in the list [bert, gpt, gpt2, t5, transfo_xl, xlnet, xlm, lxmert]"       )

