




"""simple docstring"""


import numpy as np
from nltk.translate import meteor_score

import datasets
from datasets.config import importlib_metadata, version


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


A_      =    '''\
@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},
}
'''

A_      =    '''\
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.
'''

A_      =    '''
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			):







 '''simple docstring'''





 def 			UpperCamelCase_       (    self:		Dict		):




   '''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:		Tuple,				a_:		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:		str,				a_:		Optional[Any],				a_:		Tuple,				a_:		List[str]=0.9,				a_:		List[str]=3,				a_:		Any=0.5		):




   '''simple docstring'''



   if NLTK_VERSION >= version.Version("""3.6.5"""		):
     _snake_case							:		str								=  [
         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:
     _snake_case							:		Optional[Any]								=  [
         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_		)}








"""simple docstring"""


from typing import List, Optional, Tuple, Union

import torch

from ...utils import logging, randn_tensor
from ..pipeline_utils import AudioPipelineOutput, DiffusionPipeline


A_      =    logging.get_logger(__name__)  # pylint: disable=invalid-name






class  lowercase(					__a			):







 '''simple docstring'''





 def __init__(    self:		Optional[int],				a_:		str,				a_:		Optional[Any]		):




   '''simple docstring'''



   super().__init__()
   self.register_modules(unet=a_,				scheduler=a_		)


 @torch.no_grad()
 def __call__(    self:		Any,				a_:		int = 1,				a_:		int = 100,				a_:		Optional[Union[torch.Generator, List[torch.Generator]]] = None,				a_:		Optional[float] = None,				a_:		bool = True,				):




   '''simple docstring'''



   if audio_length_in_s is None:
     _snake_case							:		Dict								=  self.unet.config.sample_size / self.unet.config.sample_rate

   _snake_case							:		Optional[int]								=  audio_length_in_s * self.unet.config.sample_rate

   _snake_case							:		int								=  2 ** len(self.unet.up_blocks		)
   if sample_size < 3 * down_scale_factor:
     raise ValueError(
         f"{audio_length_in_s} is too small. Make sure it's bigger or equal to"
         f" {3 * down_scale_factor / self.unet.config.sample_rate}."		)

   _snake_case							:		Union[str, Any]								=  int(a_		)
   if sample_size % down_scale_factor != 0:
     _snake_case							:		Optional[Any]								=  (
         (audio_length_in_s * self.unet.config.sample_rate) // down_scale_factor + 1
     ) * down_scale_factor
     logger.info(
         f"{audio_length_in_s} is increased to {sample_size / self.unet.config.sample_rate} so that it can be handled"
         f" by the model. It will be cut to {original_sample_size / self.unet.config.sample_rate} after the denoising"
         """ process."""		)
   _snake_case							:		str								=  int(a_		)

   _snake_case							:		int								=  next(iter(self.unet.parameters()		)		).dtype
   _snake_case							:		Optional[Any]								=  (batch_size, self.unet.config.in_channels, sample_size)
   if isinstance(a_,				a_		) and len(a_		) != batch_size:
     raise ValueError(
         f"You have passed a list of generators of length {len(a_		)}, but requested an effective batch"
         f" size of {batch_size}. Make sure the batch size matches the length of the generators."		)

   _snake_case							:		Optional[Any]								=  randn_tensor(a_,				generator=a_,				device=self.device,				dtype=a_		)

   # set step values
   self.scheduler.set_timesteps(a_,				device=audio.device		)
   _snake_case							:		Optional[int]								=  self.scheduler.timesteps.to(a_		)

   for t in self.progress_bar(self.scheduler.timesteps		):
     # 1. predict noise model_output
     _snake_case							:		str								=  self.unet(a_,				a_		).sample

     # 2. compute previous image: x_t -> t_t-1
     _snake_case							:		Optional[Any]								=  self.scheduler.step(a_,				a_,				a_		).prev_sample

   _snake_case							:		Tuple								=  audio.clamp(-1,				1		).float().cpu().numpy()

   _snake_case							:		Dict								=  audio[:, :, :original_sample_size]

   if not return_dict:
     return (audio,)

   return AudioPipelineOutput(audios=a_		)


