






import numpy as np
from nltk.translate import meteor_score

import datasets
from datasets.config import importlib_metadata, version


SCREAMING_SNAKE_CASE__      :			List[str]							=		version.parse(importlib_metadata.version("""nltk"""))
if NLTK_VERSION >= version.Version("""3.6.4"""):
					from nltk import word_tokenize


SCREAMING_SNAKE_CASE__      :			Tuple							=		'''\
@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},
}
'''

SCREAMING_SNAKE_CASE__      :			Optional[Any]							=		'''\
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.
'''

SCREAMING_SNAKE_CASE__      :			str							=		'''
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 						lowerCamelCase_				(      datasets.Metric ):







				def 			A	(						self     ):
								"""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 			A	(						self       ,					__lowerCAmelCase     ):
								"""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 			A	(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase=0.9       ,					__lowerCAmelCase=3       ,					__lowerCAmelCase=0.5     ):
								"""simple docstring"""
								if NLTK_VERSION >= version.Version('''3.6.5'''     ):
												__magic_name__		:List[str]        =			[
												    meteor_score.single_meteor_score(
												        word_tokenize(lowerCAmelCase__     )       ,					word_tokenize(lowerCAmelCase__     )       ,					alpha=lowerCAmelCase__       ,					beta=lowerCAmelCase__       ,					gamma=lowerCAmelCase__     )
												    for ref, pred in zip(lowerCAmelCase__       ,					lowerCAmelCase__     )
												]
								else:
												__magic_name__		:List[Any]        =			[
												    meteor_score.single_meteor_score(lowerCAmelCase__       ,					lowerCAmelCase__       ,					alpha=lowerCAmelCase__       ,					beta=lowerCAmelCase__       ,					gamma=lowerCAmelCase__     )
												    for ref, pred in zip(lowerCAmelCase__       ,					lowerCAmelCase__     )
												]

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














import argparse
import json
import logging
import os
import sys
from unittest.mock import patch

from transformers.testing_utils import TestCasePlus, get_gpu_count, slow


SCREAMING_SNAKE_CASE__      :			List[str]							=		[
    os.path.join(os.path.dirname(__file__), dirname)
    for dirname in [
        """text-classification""",
        """language-modeling""",
        """summarization""",
        """token-classification""",
        """question-answering""",
    ]
]
sys.path.extend(SRC_DIRS)


if SRC_DIRS is not None:
					import run_clm_flax
					import run_flax_glue
					import run_flax_ner
					import run_mlm_flax
					import run_qa
					import run_summarization_flax
					import run_ta_mlm_flax


logging.basicConfig(level=logging.DEBUG)

SCREAMING_SNAKE_CASE__      :			int							=		logging.getLogger()

def      __lowercase					( ):







				"""simple docstring"""






				__magic_name__		:int        =      argparse.ArgumentParser()
				parser.add_argument('''-f''' )
				__magic_name__		:Tuple        =      parser.parse_args()
				return args.f

def      __lowercase					( snake_case,  snake_case="eval" ):







				"""simple docstring"""






				__magic_name__		:str        =      os.path.join(snake_case,  f'''{split}_results.json''' )
				if os.path.exists(snake_case ):
								with open(snake_case,  '''r''' ) as f:
												return json.load(snake_case )
				raise ValueError(f'''can\'t find {path}''' )


SCREAMING_SNAKE_CASE__      :			Tuple							=		logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)

class 						lowerCamelCase_				(      lowerCamelCase ):







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Optional[Any]        =      self.get_auto_remove_tmp_dir()
								__magic_name__		:Optional[Any]        =      F'''
            run_glue.py
            --model_name_or_path distilbert-base-uncased
            --output_dir {tmp_dir}
            --train_file ./tests/fixtures/tests_samples/MRPC/train.csv
            --validation_file ./tests/fixtures/tests_samples/MRPC/dev.csv
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --learning_rate=1e-4
            --eval_steps=2
            --warmup_steps=2
            --seed=42
            --max_seq_length=128
            '''.split()

								with patch.object(__lowerCAmelCase       ,					'''argv'''       ,					__lowerCAmelCase     ):
												run_flax_glue.main()
												__magic_name__		:int        =      get_results(__lowerCAmelCase     )
												self.assertGreaterEqual(result['''eval_accuracy''']       ,					0.75     )







				@slow
				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:List[str]        =      self.get_auto_remove_tmp_dir()
								__magic_name__		:Tuple        =      F'''
            run_clm_flax.py
            --model_name_or_path distilgpt2
            --train_file ./tests/fixtures/sample_text.txt
            --validation_file ./tests/fixtures/sample_text.txt
            --do_train
            --do_eval
            --block_size 128
            --per_device_train_batch_size 4
            --per_device_eval_batch_size 4
            --num_train_epochs 2
            --logging_steps 2 --eval_steps 2
            --output_dir {tmp_dir}
            --overwrite_output_dir
            '''.split()

								with patch.object(__lowerCAmelCase       ,					'''argv'''       ,					__lowerCAmelCase     ):
												run_clm_flax.main()
												__magic_name__		:int        =      get_results(__lowerCAmelCase     )
												self.assertLess(result['''eval_perplexity''']       ,					1_0_0     )







				@slow
				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Union[str, Any]        =      self.get_auto_remove_tmp_dir()
								__magic_name__		:List[str]        =      F'''
            run_summarization.py
            --model_name_or_path t5-small
            --train_file tests/fixtures/tests_samples/xsum/sample.json
            --validation_file tests/fixtures/tests_samples/xsum/sample.json
            --test_file tests/fixtures/tests_samples/xsum/sample.json
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --num_train_epochs=3
            --warmup_steps=8
            --do_train
            --do_eval
            --do_predict
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
            --predict_with_generate
        '''.split()

								with patch.object(__lowerCAmelCase       ,					'''argv'''       ,					__lowerCAmelCase     ):
												run_summarization_flax.main()
												__magic_name__		:int        =      get_results(__lowerCAmelCase       ,					split='''test'''     )
												self.assertGreaterEqual(result['''test_rouge1''']       ,					1_0     )
												self.assertGreaterEqual(result['''test_rouge2''']       ,					2     )
												self.assertGreaterEqual(result['''test_rougeL''']       ,					7     )
												self.assertGreaterEqual(result['''test_rougeLsum''']       ,					7     )







				@slow
				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Dict        =      self.get_auto_remove_tmp_dir()
								__magic_name__		:Optional[Any]        =      F'''
            run_mlm.py
            --model_name_or_path distilroberta-base
            --train_file ./tests/fixtures/sample_text.txt
            --validation_file ./tests/fixtures/sample_text.txt
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --max_seq_length 128
            --per_device_train_batch_size 4
            --per_device_eval_batch_size 4
            --logging_steps 2 --eval_steps 2
            --do_train
            --do_eval
            --num_train_epochs=1
        '''.split()

								with patch.object(__lowerCAmelCase       ,					'''argv'''       ,					__lowerCAmelCase     ):
												run_mlm_flax.main()
												__magic_name__		:int        =      get_results(__lowerCAmelCase     )
												self.assertLess(result['''eval_perplexity''']       ,					4_2     )







				@slow
				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Tuple        =      self.get_auto_remove_tmp_dir()
								__magic_name__		:List[Any]        =      F'''
            run_t5_mlm_flax.py
            --model_name_or_path t5-small
            --train_file ./tests/fixtures/sample_text.txt
            --validation_file ./tests/fixtures/sample_text.txt
            --do_train
            --do_eval
            --max_seq_length 128
            --per_device_train_batch_size 4
            --per_device_eval_batch_size 4
            --num_train_epochs 2
            --logging_steps 2 --eval_steps 2
            --output_dir {tmp_dir}
            --overwrite_output_dir
            '''.split()

								with patch.object(__lowerCAmelCase       ,					'''argv'''       ,					__lowerCAmelCase     ):
												run_ta_mlm_flax.main()
												__magic_name__		:Dict        =      get_results(__lowerCAmelCase     )
												self.assertGreaterEqual(result['''eval_accuracy''']       ,					0.42     )







				@slow
				def 			A	(						self     ):
								"""simple docstring"""
								# with so little data distributed training needs more epochs to get the score on par with 0/1 gpu
								__magic_name__		:int        =      7 if get_gpu_count() > 1 else 2

								__magic_name__		:str        =      self.get_auto_remove_tmp_dir()
								__magic_name__		:str        =      F'''
            run_flax_ner.py
            --model_name_or_path bert-base-uncased
            --train_file tests/fixtures/tests_samples/conll/sample.json
            --validation_file tests/fixtures/tests_samples/conll/sample.json
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --do_train
            --do_eval
            --warmup_steps=2
            --learning_rate=2e-4
            --logging_steps 2 --eval_steps 2
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=2
            --num_train_epochs={epochs}
            --seed 7
        '''.split()

								with patch.object(__lowerCAmelCase       ,					'''argv'''       ,					__lowerCAmelCase     ):
												run_flax_ner.main()
												__magic_name__		:Any        =      get_results(__lowerCAmelCase     )
												self.assertGreaterEqual(result['''eval_accuracy''']       ,					0.75     )
												self.assertGreaterEqual(result['''eval_f1''']       ,					0.3     )







				@slow
				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Union[str, Any]        =      self.get_auto_remove_tmp_dir()
								__magic_name__		:int        =      F'''
            run_qa.py
            --model_name_or_path bert-base-uncased
            --version_2_with_negative
            --train_file tests/fixtures/tests_samples/SQUAD/sample.json
            --validation_file tests/fixtures/tests_samples/SQUAD/sample.json
            --output_dir {tmp_dir}
            --overwrite_output_dir
            --num_train_epochs=3
            --warmup_steps=2
            --do_train
            --do_eval
            --logging_steps 2 --eval_steps 2
            --learning_rate=2e-4
            --per_device_train_batch_size=2
            --per_device_eval_batch_size=1
        '''.split()

								with patch.object(__lowerCAmelCase       ,					'''argv'''       ,					__lowerCAmelCase     ):
												run_qa.main()
												__magic_name__		:int        =      get_results(__lowerCAmelCase     )
												self.assertGreaterEqual(result['''eval_f1''']       ,					3_0     )
												self.assertGreaterEqual(result['''eval_exact''']       ,					3_0     )






