
"""simple docstring"""






import numpy as np
from nltk.translate import meteor_score

import datasets
from datasets.config import importlib_metadata, version


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


UpperCAmelCase        =				"""\
@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},
}
"""

UpperCAmelCase        =				"""\
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.
"""

UpperCAmelCase        =				"""
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 			lowercase					( datasets.Metric		):






			def 					UpperCAmelCase							(self  :	Optional[int]			)       ->	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  :	Optional[int]      ,SCREAMING_SNAKE_CASE_  :	Dict			)       ->	Any:





				"""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  :	int      ,SCREAMING_SNAKE_CASE_  :	Dict      ,SCREAMING_SNAKE_CASE_  :	int      ,SCREAMING_SNAKE_CASE_  :	List[str]=0.9      ,SCREAMING_SNAKE_CASE_  :	Dict=3      ,SCREAMING_SNAKE_CASE_  :	Union[str, Any]=0.5			)       ->	Dict:





				"""simple docstring"""


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

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




"""simple docstring"""






from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


UpperCAmelCase        =				logging.get_logger(__name__)

UpperCAmelCase        =				{
    """shi-labs/nat-mini-in1k-224""": """https://huggingface.co/shi-labs/nat-mini-in1k-224/resolve/main/config.json""",
    # See all Nat models at https://huggingface.co/models?filter=nat
}



class 			lowercase					( lowercase__   ,lowercase__		):
			lowercase        =     '''nat'''

			lowercase        =     {
			    '''num_attention_heads''': '''num_heads''',
			    '''num_hidden_layers''': '''num_layers''',
			}






			def __init__(self  :	Union[str, Any]      ,SCREAMING_SNAKE_CASE_  :	Optional[Any]=4      ,SCREAMING_SNAKE_CASE_  :	Dict=3      ,SCREAMING_SNAKE_CASE_  :	int=64      ,SCREAMING_SNAKE_CASE_  :	Tuple=[3, 4, 6, 5]      ,SCREAMING_SNAKE_CASE_  :	Dict=[2, 4, 8, 16]      ,SCREAMING_SNAKE_CASE_  :	Optional[int]=7      ,SCREAMING_SNAKE_CASE_  :	Optional[Any]=3.0      ,SCREAMING_SNAKE_CASE_  :	Optional[Any]=True      ,SCREAMING_SNAKE_CASE_  :	Any=0.0      ,SCREAMING_SNAKE_CASE_  :	List[Any]=0.0      ,SCREAMING_SNAKE_CASE_  :	Dict=0.1      ,SCREAMING_SNAKE_CASE_  :	Tuple="gelu"      ,SCREAMING_SNAKE_CASE_  :	str=0.02      ,SCREAMING_SNAKE_CASE_  :	str=1e-5      ,SCREAMING_SNAKE_CASE_  :	int=0.0      ,SCREAMING_SNAKE_CASE_  :	List[Any]=None      ,SCREAMING_SNAKE_CASE_  :	Tuple=None      ,**SCREAMING_SNAKE_CASE_  :	Union[str, Any]      ,)       ->	Tuple:





				"""simple docstring"""


				super().__init__(**SCREAMING_SNAKE_CASE_			)

				lowerCAmelCase												=  patch_size
				lowerCAmelCase												=  num_channels
				lowerCAmelCase												=  embed_dim
				lowerCAmelCase												=  depths
				lowerCAmelCase												=  len(SCREAMING_SNAKE_CASE_			)
				lowerCAmelCase												=  num_heads
				lowerCAmelCase												=  kernel_size
				lowerCAmelCase												=  mlp_ratio
				lowerCAmelCase												=  qkv_bias
				lowerCAmelCase												=  hidden_dropout_prob
				lowerCAmelCase												=  attention_probs_dropout_prob
				lowerCAmelCase												=  drop_path_rate
				lowerCAmelCase												=  hidden_act
				lowerCAmelCase												=  layer_norm_eps
				lowerCAmelCase												=  initializer_range
				# we set the hidden_size attribute in order to make Nat work with VisionEncoderDecoderModel
				# this indicates the channel dimension after the last stage of the model
				lowerCAmelCase												=  int(embed_dim * 2 ** (len(SCREAMING_SNAKE_CASE_			) - 1)			)
				lowerCAmelCase												=  layer_scale_init_value
				lowerCAmelCase												=  ['''stem'''] + [F"""stage{idx}""" for idx in range(1      ,len(SCREAMING_SNAKE_CASE_			) + 1			)]
				lowerCAmelCase							,       lowerCAmelCase												=  get_aligned_output_features_output_indices(
				    out_features=SCREAMING_SNAKE_CASE_      ,out_indices=SCREAMING_SNAKE_CASE_      ,stage_names=self.stage_names			)


