



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

import datasets
from datasets.config import importlib_metadata, version


_lowerCAmelCase       :Optional[Any]	=   version.parse(importlib_metadata.version('nltk'))
if NLTK_VERSION >= version.Version('3.6.4'):
  from nltk import word_tokenize


_lowerCAmelCase       :int	=   '\\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'

_lowerCAmelCase       :Any	=   '\\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'

_lowerCAmelCase       :str	=   '\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 					__lowerCAmelCase      (   self						)				->   List[Any]:
         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 					__lowerCAmelCase      (   self			,      A						)				->   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 					__lowerCAmelCase      (   self			,      A			,      A			,      A=0.9			,      A=3			,      A=0.5						)				->   Optional[Any]:
         if NLTK_VERSION >= version.Version('''3.6.5'''						):
             _UpperCAmelCase				:    List[Any]											=       [
                 meteor_score.single_meteor_score(
                     word_tokenize(__A						)			,      word_tokenize(__A						)			,      alpha=__A			,      beta=__A			,      gamma=__A						)
                 for ref, pred in zip(__A			,      __A						)
             ]
         else:
             _UpperCAmelCase				:    int											=       [
                 meteor_score.single_meteor_score(__A			,      __A			,      alpha=__A			,      beta=__A			,      gamma=__A						)
                 for ref, pred in zip(__A			,      __A						)
             ]

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




import torch

from diffusers import DPMSolverSDEScheduler
from diffusers.utils import torch_device
from diffusers.utils.testing_utils import require_torchsde

from .test_schedulers import SchedulerCommonTest


@require_torchsde
class 			lowercase_		(      A       ):
       __lowerCamelCase				       =						(DPMSolverSDEScheduler,)
       __lowerCamelCase				       =						1_0


       def 	_snake_case				(    self						,       **__A				)						->    Union[str, Any]:
              SCREAMING_SNAKE_CASE_							:				Optional[int]		={
                  '''num_train_timesteps''': 1_100,
                  '''beta_start''': 0.0_001,
                  '''beta_end''': 0.02,
                  '''beta_schedule''': '''linear''',
                  '''noise_sampler_seed''': 0,
              }

              config.update(**__A				)
              return config


       def 	_snake_case				(    self				)						->    Any:
              for timesteps in [10, 50, 100, 1_000]:
                     self.check_over_configs(num_train_timesteps=__A				)


       def 	_snake_case				(    self				)						->    Union[str, Any]:
              for beta_start, beta_end in zip([0.00_001, 0.0_001, 0.001]						,       [0.0_002, 0.002, 0.02]				):
                     self.check_over_configs(beta_start=__A						,       beta_end=__A				)


       def 	_snake_case				(    self				)						->    Tuple:
              for schedule in ["linear", "scaled_linear"]:
                     self.check_over_configs(beta_schedule=__A				)


       def 	_snake_case				(    self				)						->    List[str]:
              for prediction_type in ["epsilon", "v_prediction"]:
                     self.check_over_configs(prediction_type=__A				)


       def 	_snake_case				(    self				)						->    int:
              SCREAMING_SNAKE_CASE_							:				Union[str, Any]		=self.scheduler_classes[0]
              SCREAMING_SNAKE_CASE_							:				List[str]		=self.get_scheduler_config()
              SCREAMING_SNAKE_CASE_							:				List[str]		=scheduler_class(**__A				)

              scheduler.set_timesteps(self.num_inference_steps				)

              SCREAMING_SNAKE_CASE_							:				int		=self.dummy_model()
              SCREAMING_SNAKE_CASE_							:				List[str]		=self.dummy_sample_deter * scheduler.init_noise_sigma
              SCREAMING_SNAKE_CASE_							:				int		=sample.to(__A				)

              for i, t in enumerate(scheduler.timesteps				):
                     SCREAMING_SNAKE_CASE_							:				List[Any]		=scheduler.scale_model_input(__A						,       __A				)

                     SCREAMING_SNAKE_CASE_							:				Dict		=model(__A						,       __A				)

                     SCREAMING_SNAKE_CASE_							:				Tuple		=scheduler.step(__A						,       __A						,       __A				)
                     SCREAMING_SNAKE_CASE_							:				str		=output.prev_sample

              SCREAMING_SNAKE_CASE_							:				Optional[int]		=torch.sum(torch.abs(__A				)				)
              SCREAMING_SNAKE_CASE_							:				List[str]		=torch.mean(torch.abs(__A				)				)

              if torch_device in ["mps"]:
                     assert abs(result_sum.item() - 167.47_821_044_921_875				) < 1e-2
                     assert abs(result_mean.item() - 0.2_178_705_964_565_277				) < 1e-3
              elif torch_device in ["cuda"]:
                     assert abs(result_sum.item() - 171.59_352_111_816_406				) < 1e-2
                     assert abs(result_mean.item() - 0.22_342_906_892_299_652				) < 1e-3
              else:
                     assert abs(result_sum.item() - 162.52_383_422_851_562				) < 1e-2
                     assert abs(result_mean.item() - 0.211_619_570_851_326				) < 1e-3


       def 	_snake_case				(    self				)						->    Dict:
              SCREAMING_SNAKE_CASE_							:				List[str]		=self.scheduler_classes[0]
              SCREAMING_SNAKE_CASE_							:				Optional[int]		=self.get_scheduler_config(prediction_type='''v_prediction'''				)
              SCREAMING_SNAKE_CASE_							:				List[Any]		=scheduler_class(**__A				)

              scheduler.set_timesteps(self.num_inference_steps				)

              SCREAMING_SNAKE_CASE_							:				Tuple		=self.dummy_model()
              SCREAMING_SNAKE_CASE_							:				Optional[Any]		=self.dummy_sample_deter * scheduler.init_noise_sigma
              SCREAMING_SNAKE_CASE_							:				Tuple		=sample.to(__A				)

              for i, t in enumerate(scheduler.timesteps				):
                     SCREAMING_SNAKE_CASE_							:				Union[str, Any]		=scheduler.scale_model_input(__A						,       __A				)

                     SCREAMING_SNAKE_CASE_							:				str		=model(__A						,       __A				)

                     SCREAMING_SNAKE_CASE_							:				Any		=scheduler.step(__A						,       __A						,       __A				)
                     SCREAMING_SNAKE_CASE_							:				Tuple		=output.prev_sample

              SCREAMING_SNAKE_CASE_							:				Optional[int]		=torch.sum(torch.abs(__A				)				)
              SCREAMING_SNAKE_CASE_							:				Optional[int]		=torch.mean(torch.abs(__A				)				)

              if torch_device in ["mps"]:
                     assert abs(result_sum.item() - 124.77_149_200_439_453				) < 1e-2
                     assert abs(result_mean.item() - 0.16_226_289_014_816_284				) < 1e-3
              elif torch_device in ["cuda"]:
                     assert abs(result_sum.item() - 128.1_663_360_595_703				) < 1e-2
                     assert abs(result_mean.item() - 0.16_688_326_001_167_297				) < 1e-3
              else:
                     assert abs(result_sum.item() - 119.8_487_548_828_125				) < 1e-2
                     assert abs(result_mean.item() - 0.1_560_530_662_536_621				) < 1e-3


       def 	_snake_case				(    self				)						->    int:
              SCREAMING_SNAKE_CASE_							:				Union[str, Any]		=self.scheduler_classes[0]
              SCREAMING_SNAKE_CASE_							:				Optional[Any]		=self.get_scheduler_config()
              SCREAMING_SNAKE_CASE_							:				List[str]		=scheduler_class(**__A				)

              scheduler.set_timesteps(self.num_inference_steps						,       device=__A				)

              SCREAMING_SNAKE_CASE_							:				int		=self.dummy_model()
              SCREAMING_SNAKE_CASE_							:				int		=self.dummy_sample_deter.to(__A				) * scheduler.init_noise_sigma

              for t in scheduler.timesteps:
                     SCREAMING_SNAKE_CASE_							:				Union[str, Any]		=scheduler.scale_model_input(__A						,       __A				)

                     SCREAMING_SNAKE_CASE_							:				Dict		=model(__A						,       __A				)

                     SCREAMING_SNAKE_CASE_							:				Optional[Any]		=scheduler.step(__A						,       __A						,       __A				)
                     SCREAMING_SNAKE_CASE_							:				List[Any]		=output.prev_sample

              SCREAMING_SNAKE_CASE_							:				List[Any]		=torch.sum(torch.abs(__A				)				)
              SCREAMING_SNAKE_CASE_							:				int		=torch.mean(torch.abs(__A				)				)

              if torch_device in ["mps"]:
                     assert abs(result_sum.item() - 167.46_957_397_460_938				) < 1e-2
                     assert abs(result_mean.item() - 0.21_805_934_607_982_635				) < 1e-3
              elif torch_device in ["cuda"]:
                     assert abs(result_sum.item() - 171.59_353_637_695_312				) < 1e-2
                     assert abs(result_mean.item() - 0.22_342_908_382_415_771				) < 1e-3
              else:
                     assert abs(result_sum.item() - 162.52_383_422_851_562				) < 1e-2
                     assert abs(result_mean.item() - 0.211_619_570_851_326				) < 1e-3





       def 	_snake_case				(    self				)						->    List[Any]:
              SCREAMING_SNAKE_CASE_							:				Union[str, Any]		=self.scheduler_classes[0]
              SCREAMING_SNAKE_CASE_							:				List[str]		=self.get_scheduler_config()
              SCREAMING_SNAKE_CASE_							:				Dict		=scheduler_class(**__A						,       use_karras_sigmas=__A				)

              scheduler.set_timesteps(self.num_inference_steps						,       device=__A				)

              SCREAMING_SNAKE_CASE_							:				Dict		=self.dummy_model()
              SCREAMING_SNAKE_CASE_							:				List[Any]		=self.dummy_sample_deter.to(__A				) * scheduler.init_noise_sigma
              SCREAMING_SNAKE_CASE_							:				str		=sample.to(__A				)

              for t in scheduler.timesteps:
                     SCREAMING_SNAKE_CASE_							:				Any		=scheduler.scale_model_input(__A						,       __A				)

                     SCREAMING_SNAKE_CASE_							:				Optional[Any]		=model(__A						,       __A				)

                     SCREAMING_SNAKE_CASE_							:				int		=scheduler.step(__A						,       __A						,       __A				)
                     SCREAMING_SNAKE_CASE_							:				List[str]		=output.prev_sample

              SCREAMING_SNAKE_CASE_							:				str		=torch.sum(torch.abs(__A				)				)
              SCREAMING_SNAKE_CASE_							:				List[Any]		=torch.mean(torch.abs(__A				)				)

              if torch_device in ["mps"]:
                     assert abs(result_sum.item() - 176.66_974_135_742_188				) < 1e-2
                     assert abs(result_mean.item() - 0.23_003_872_730_981_811				) < 1e-2
              elif torch_device in ["cuda"]:
                     assert abs(result_sum.item() - 177.63_653_564_453_125				) < 1e-2
                     assert abs(result_mean.item() - 0.23_003_872_730_981_811				) < 1e-2
              else:
                     assert abs(result_sum.item() - 170.3_135_223_388_672				) < 1e-2
                     assert abs(result_mean.item() - 0.23_003_872_730_981_811				) < 1e-2
