




'''simple docstring'''
import numpy as np
from nltk.translate import meteor_score

import datasets
from datasets.config import importlib_metadata, version


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


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

_SCREAMING_SNAKE_CASE			=						"\\nMETEOR, an automatic metric for machine translation evaluation\nthat is based on a generalized concept of unigram matching between the\nmachine-produced translation and human-produced reference translations.\nUnigrams can be matched based on their surface forms, stemmed forms,\nand meanings; furthermore, METEOR can be easily extended to include more\nadvanced matching strategies. Once all generalized unigram matches\nbetween the two strings have been found, METEOR computes a score for\nthis matching using a combination of unigram-precision, unigram-recall, and\na measure of fragmentation that is designed to directly capture how\nwell-ordered the matched words in the machine translation are in relation\nto the reference.\n\nMETEOR gets an R correlation value of 0.347 with human evaluation on the Arabic\ndata and 0.331 on the Chinese data. This is shown to be an improvement on\nusing simply unigram-precision, unigram-recall and their harmonic F1\ncombination.\n"

_SCREAMING_SNAKE_CASE			=						"\nComputes METEOR score of translated segments against one or more references.\nArgs:\n    predictions: list of predictions to score. Each prediction\n        should be a string with tokens separated by spaces.\n    references: list of reference for each prediction. Each\n        reference should be a string with tokens separated by spaces.\n    alpha: Parameter for controlling relative weights of precision and recall. default: 0.9\n    beta: Parameter for controlling shape of penalty as a function of fragmentation. default: 3\n    gamma: Relative weight assigned to fragmentation penalty. default: 0.5\nReturns:\n    'meteor': meteor score.\nExamples:\n\n    >>> meteor = datasets.load_metric('meteor')\n    >>> predictions = [\"It is a guide to action which ensures that the military always obeys the commands of the party\"]\n    >>> references = [\"It is a guide to action that ensures that the military will forever heed Party commands\"]\n    >>> results = meteor.compute(predictions=predictions, references=references)\n    >>> print(round(results[\"meteor\"], 4))\n    0.6944\n"
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION			,_KWARGS_DESCRIPTION				)
class   __UpperCAmelCase				(     datasets.Metric				):



					'''simple docstring'''





					def     __snake_case						(	self     :						List[Any])    ->							List[str]:
								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     __snake_case						(	self     :						Any      ,       _lowercase     :						Tuple)    ->							str:
								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     __snake_case						(	self     :						List[str]      ,       _lowercase     :						Optional[Any]      ,       _lowercase     :						List[Any]      ,       _lowercase     :						int=0.9      ,       _lowercase     :						List[str]=3      ,       _lowercase     :						Dict=0.5)    ->							Tuple:
								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)}










'''simple docstring'''
from ...configuration_utils import PretrainedConfig
from ...utils import logging


_SCREAMING_SNAKE_CASE			=						logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE			=						{"openai-gpt": "https://huggingface.co/openai-gpt/resolve/main/config.json"}
class   __UpperCAmelCase				(     lowerCAmelCase				):



					'''simple docstring'''





					_UpperCamelCase							=		"""openai-gpt"""
					_UpperCamelCase							=		{
					    """max_position_embeddings""": """n_positions""",
					    """hidden_size""": """n_embd""",
					    """num_attention_heads""": """n_head""",
					    """num_hidden_layers""": """n_layer""",
					}



					def __init__(	self     :						Any      ,       _lowercase     :						List[Any]=40_478      ,       _lowercase     :						Tuple=512      ,       _lowercase     :						Dict=768      ,       _lowercase     :						List[str]=12      ,       _lowercase     :						Optional[int]=12      ,       _lowercase     :						Tuple="gelu"      ,       _lowercase     :						int=0.1      ,       _lowercase     :						Tuple=0.1      ,       _lowercase     :						Any=0.1      ,       _lowercase     :						List[str]=1E-5      ,       _lowercase     :						str=0.02      ,       _lowercase     :						Optional[Any]="cls_index"      ,       _lowercase     :						int=True      ,       _lowercase     :						str=None      ,       _lowercase     :						Tuple=True      ,       _lowercase     :						List[Any]=0.1      ,       **_lowercase     :						int      ,       )    ->							Optional[int]:
								A_									= vocab_size
								A_									= n_positions
								A_									= n_embd
								A_									= n_layer
								A_									= n_head
								A_									= afn
								A_									= resid_pdrop
								A_									= embd_pdrop
								A_									= attn_pdrop
								A_									= layer_norm_epsilon
								A_									= initializer_range
								A_									= summary_type
								A_									= summary_use_proj
								A_									= summary_activation
								A_									= summary_first_dropout
								A_									= summary_proj_to_labels
								super().__init__(**_lowercase)




