





"""simple docstring"""
import os

from bleurt import score  # From: git+https://github.com/google-research/bleurt.git

import datasets


__UpperCamelCase     :						List[Any]						       =  datasets.logging.get_logger(__name__)


__UpperCamelCase     :						Union[str, Any]						       =  '''\
@inproceedings{bleurt,
  title={BLEURT: Learning Robust Metrics for Text Generation},
  author={Thibault Sellam and Dipanjan Das and Ankur P. Parikh},
  booktitle={ACL},
  year={2020},
  url={https://arxiv.org/abs/2004.04696}
}
'''

__UpperCamelCase     :						Optional[int]						       =  '''\
BLEURT a learnt evaluation metric for Natural Language Generation. It is built using multiple phases of transfer learning starting from a pretrained BERT model (Devlin et al. 2018)
and then employing another pre-training phrase using synthetic data. Finally it is trained on WMT human annotations. You may run BLEURT out-of-the-box or fine-tune
it for your specific application (the latter is expected to perform better).

See the project\'s README at https://github.com/google-research/bleurt#readme for more information.
'''

__UpperCamelCase     :						Optional[Any]						       =  '''
BLEURT score.

Args:
    `predictions` (list of str): prediction/candidate sentences
    `references` (list of str): reference sentences
    `checkpoint` BLEURT checkpoint. Will default to BLEURT-tiny if None.

Returns:
    \'scores\': List of scores.
Examples:

    >>> predictions = ["hello there", "general kenobi"]
    >>> references = ["hello there", "general kenobi"]
    >>> bleurt = datasets.load_metric("bleurt")
    >>> results = bleurt.compute(predictions=predictions, references=references)
    >>> print([round(v, 2) for v in results["scores"]])
    [1.03, 1.04]
'''

__UpperCamelCase     :						str						       =  {
    '''bleurt-tiny-128''': '''https://storage.googleapis.com/bleurt-oss/bleurt-tiny-128.zip''',
    '''bleurt-tiny-512''': '''https://storage.googleapis.com/bleurt-oss/bleurt-tiny-512.zip''',
    '''bleurt-base-128''': '''https://storage.googleapis.com/bleurt-oss/bleurt-base-128.zip''',
    '''bleurt-base-512''': '''https://storage.googleapis.com/bleurt-oss/bleurt-base-512.zip''',
    '''bleurt-large-128''': '''https://storage.googleapis.com/bleurt-oss/bleurt-large-128.zip''',
    '''bleurt-large-512''': '''https://storage.googleapis.com/bleurt-oss/bleurt-large-512.zip''',
    '''BLEURT-20-D3''': '''https://storage.googleapis.com/bleurt-oss-21/BLEURT-20-D3.zip''',
    '''BLEURT-20-D6''': '''https://storage.googleapis.com/bleurt-oss-21/BLEURT-20-D6.zip''',
    '''BLEURT-20-D12''': '''https://storage.googleapis.com/bleurt-oss-21/BLEURT-20-D12.zip''',
    '''BLEURT-20''': '''https://storage.googleapis.com/bleurt-oss-21/BLEURT-20.zip''',
}







@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION   , _KWARGS_DESCRIPTION  )
class       a							(   datasets.Metric  ):



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  return datasets.MetricInfo(
      description=_DESCRIPTION				,       citation=_CITATION				,       homepage='https://github.com/google-research/bleurt'				,       inputs_description=_KWARGS_DESCRIPTION				,       features=datasets.Features(
          {
              'predictions': datasets.Value('string'				,       id='sequence'     ),
              'references': datasets.Value('string'				,       id='sequence'     ),
          }     )				,       codebase_urls=['https://github.com/google-research/bleurt']				,       reference_urls=['https://github.com/google-research/bleurt', 'https://arxiv.org/abs/2004.04696']				,       )



 def    UpperCamelCase__  (     self				,       _snake_case     ):







  """simple docstring"""






  if self.config_name == "default":
   logger.warning(
       'Using default BLEURT-Base checkpoint for sequence maximum length 128. '
       'You can use a bigger model for better results with e.g.: datasets.load_metric(\'bleurt\', \'bleurt-large-512\').'     )
   lowerCAmelCase    				= 'bleurt-base-128'

  if self.config_name.lower() in CHECKPOINT_URLS:
   lowerCAmelCase    				= self.config_name.lower()

  elif self.config_name.upper() in CHECKPOINT_URLS:
   lowerCAmelCase    				= self.config_name.upper()

  else:
   raise KeyError(
       F'{self.config_name} model not found. You should supply the name of a model checkpoint for bleurt in {CHECKPOINT_URLS.keys()}'     )

  # download the model checkpoint specified by self.config_name and set up the scorer
  lowerCAmelCase    				= dl_manager.download_and_extract(CHECKPOINT_URLS[checkpoint_name]     )
  lowerCAmelCase    				= score.BleurtScorer(os.path.join(_snake_case				,       _snake_case     )     )



 def    UpperCamelCase__  (     self				,       _snake_case				,       _snake_case     ):







  """simple docstring"""






  lowerCAmelCase    				= self.scorer.score(references=_snake_case				,       candidates=_snake_case     )
  return {"scores": scores}













"""simple docstring"""
import unittest

import numpy as np

from transformers import DistilBertConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask


if is_flax_available():
			import jax.numpy as jnp

			from transformers.models.distilbert.modeling_flax_distilbert import (
			    FlaxDistilBertForMaskedLM,
			    FlaxDistilBertForMultipleChoice,
			    FlaxDistilBertForQuestionAnswering,
			    FlaxDistilBertForSequenceClassification,
			    FlaxDistilBertForTokenClassification,
			    FlaxDistilBertModel,
			)







class      UpperCamelCase_			(unittest.TestCase	):





	def __init__( self   :					int      ,      lowerCAmelCase_   :					Any      ,      lowerCAmelCase_   :					Union[str, Any]=13      ,      lowerCAmelCase_   :					Union[str, Any]=7      ,      lowerCAmelCase_   :					Optional[Any]=True      ,      lowerCAmelCase_   :					List[Any]=True      ,      lowerCAmelCase_   :					Any=True      ,      lowerCAmelCase_   :					Tuple=True      ,      lowerCAmelCase_   :					Tuple=99      ,      lowerCAmelCase_   :					str=32      ,      lowerCAmelCase_   :					Optional[int]=5      ,      lowerCAmelCase_   :					List[Any]=4      ,      lowerCAmelCase_   :					List[Any]=37      ,      lowerCAmelCase_   :					str="gelu"      ,      lowerCAmelCase_   :					Optional[Any]=0.1      ,      lowerCAmelCase_   :					Union[str, Any]=0.1      ,      lowerCAmelCase_   :					List[Any]=512      ,      lowerCAmelCase_   :					Dict=16      ,      lowerCAmelCase_   :					int=2      ,      lowerCAmelCase_   :					Union[str, Any]=0.0_2      ,      lowerCAmelCase_   :					Optional[Any]=4      ,      )		->     Tuple:
				UpperCAmelCase_	:					Optional[Any]     	=   parent
				UpperCAmelCase_	:					Tuple     	=   batch_size
				UpperCAmelCase_	:					str     	=   seq_length
				UpperCAmelCase_	:					Optional[int]     	=   is_training
				UpperCAmelCase_	:					Dict     	=   use_attention_mask
				UpperCAmelCase_	:					int     	=   use_token_type_ids
				UpperCAmelCase_	:					Tuple     	=   use_labels
				UpperCAmelCase_	:					Tuple     	=   vocab_size
				UpperCAmelCase_	:					Union[str, Any]     	=   hidden_size
				UpperCAmelCase_	:					int     	=   num_hidden_layers
				UpperCAmelCase_	:					List[str]     	=   num_attention_heads
				UpperCAmelCase_	:					str     	=   intermediate_size
				UpperCAmelCase_	:					List[str]     	=   hidden_act
				UpperCAmelCase_	:					Tuple     	=   hidden_dropout_prob
				UpperCAmelCase_	:					Optional[Any]     	=   attention_probs_dropout_prob
				UpperCAmelCase_	:					Optional[int]     	=   max_position_embeddings
				UpperCAmelCase_	:					Optional[Any]     	=   type_vocab_size
				UpperCAmelCase_	:					Dict     	=   type_sequence_label_size
				UpperCAmelCase_	:					List[Any]     	=   initializer_range
				UpperCAmelCase_	:					Any     	=   num_choices





	def 	_SCREAMING_SNAKE_CASE ( self   :					List[str]		)		->     str:
				UpperCAmelCase_	:					List[str]     	=   ids_tensor([self.batch_size, self.seq_length]      ,      self.vocab_size		)

				UpperCAmelCase_	:					Tuple     	=   None
				if self.use_attention_mask:
							UpperCAmelCase_	:					Dict     	=   random_attention_mask([self.batch_size, self.seq_length]		)

				UpperCAmelCase_	:					Any     	=   DistilBertConfig(
				    vocab_size=self.vocab_size      ,      dim=self.hidden_size      ,      n_layers=self.num_hidden_layers      ,      n_heads=self.num_attention_heads      ,      hidden_dim=self.intermediate_size      ,      hidden_act=self.hidden_act      ,      dropout=self.hidden_dropout_prob      ,      attention_dropout=self.attention_probs_dropout_prob      ,      max_position_embeddings=self.max_position_embeddings      ,      initializer_range=self.initializer_range      ,      tie_weights_=lowerCAmelCase_      ,      )

				return config, input_ids, attention_mask





	def 	_SCREAMING_SNAKE_CASE ( self   :					List[Any]		)		->     Union[str, Any]:
				UpperCAmelCase_	:					Any     	=   self.prepare_config_and_inputs()
				UpperCAmelCase_	,      UpperCAmelCase_	,      UpperCAmelCase_	:					List[str]     	=   config_and_inputs
				UpperCAmelCase_	:					Optional[Any]     	=   {"input_ids": input_ids, "attention_mask": attention_mask}
				return config, inputs_dict







@require_flax
class      UpperCamelCase_			(__A							,		unittest.TestCase	):
	__magic_name__       =							(
	    (
	        FlaxDistilBertModel,
	        FlaxDistilBertForMaskedLM,
	        FlaxDistilBertForMultipleChoice,
	        FlaxDistilBertForQuestionAnswering,
	        FlaxDistilBertForSequenceClassification,
	        FlaxDistilBertForTokenClassification,
	        FlaxDistilBertForQuestionAnswering,
	    )
	    if is_flax_available()
	    else ()
	)





	def 	_SCREAMING_SNAKE_CASE ( self   :					List[str]		)		->     Optional[Any]:
				UpperCAmelCase_	:					List[Any]     	=   FlaxDistilBertModelTester(self		)





	@slow
	def 	_SCREAMING_SNAKE_CASE ( self   :					Optional[Any]		)		->     List[str]:
				for model_class_name in self.all_model_classes:
							UpperCAmelCase_	:					str     	=   model_class_name.from_pretrained("distilbert-base-uncased"		)
							UpperCAmelCase_	:					List[str]     	=   model(np.ones((1, 1)		)		)
							self.assertIsNotNone(lowerCAmelCase_		)







@require_flax
class      UpperCamelCase_			(unittest.TestCase	):





	@slow
	def 	_SCREAMING_SNAKE_CASE ( self   :					str		)		->     Optional[int]:
				UpperCAmelCase_	:					Any     	=   FlaxDistilBertModel.from_pretrained("distilbert-base-uncased"		)
				UpperCAmelCase_	:					int     	=   np.array([[0, 345, 232, 328, 740, 140, 1_695, 69, 6_078, 1_588, 2]]		)
				UpperCAmelCase_	:					List[str]     	=   np.array([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]		)
				UpperCAmelCase_	:					Any     	=   model(lowerCAmelCase_      ,      attention_mask=lowerCAmelCase_		)[0]
				UpperCAmelCase_	:					Union[str, Any]     	=   (1, 11, 768)
				self.assertEqual(output.shape      ,      lowerCAmelCase_		)
				UpperCAmelCase_	:					Dict     	=   np.array([[[-0.1_6_3_9, 0.3_2_9_9, 0.1_6_4_8], [-0.1_7_4_6, 0.3_2_8_9, 0.1_7_1_0], [-0.1_8_8_4, 0.3_3_5_7, 0.1_8_1_0]]]		)

				self.assertTrue(jnp.allclose(output[:, 1:4, 1:4]      ,      lowerCAmelCase_      ,      atol=1e-4		)		)



