





"""simple docstring"""






import unittest

import numpy as np
import timeout_decorator  # noqa

from transformers import BlenderbotConfig, is_flax_available
from transformers.testing_utils import jax_device, require_flax, slow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor


if is_flax_available():
  import os

  # The slow tests are often failing with OOM error on GPU
  # This makes JAX allocate exactly what is needed on demand, and deallocate memory that is no longer needed
  # but will be slower as stated here https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html
  A	     =					'''platform'''

  import jax
  import jax.numpy as jnp

  from transformers import BlenderbotTokenizer
  from transformers.models.blenderbot.modeling_flax_blenderbot import (
      FlaxBlenderbotForConditionalGeneration,
      FlaxBlenderbotModel,
      shift_tokens_right,
  )

def       __A (     a_  :str				,    a_  :int				,    a_  :Optional[Any]=None				,    a_  :Optional[Any]=None				,    a_  :List[str]=None				,    a_  :Optional[Any]=None				,    a_  :Tuple=None				,    a_  :List[Any]=None				,    )						->						Dict:
    if attention_mask is None:
        __a	:  Tuple         =					np.where(input_ids != config.pad_token_id				,    1				,    0)
    if decoder_attention_mask is None:
        __a	:  Any         =					np.where(decoder_input_ids != config.pad_token_id				,    1				,    0)
    if head_mask is None:
        __a	:  Optional[Any]         =					np.ones((config.encoder_layers, config.encoder_attention_heads))
    if decoder_head_mask is None:
        __a	:  Optional[Any]         =					np.ones((config.decoder_layers, config.decoder_attention_heads))
    if cross_attn_head_mask is None:
        __a	:  int         =					np.ones((config.decoder_layers, config.decoder_attention_heads))
    return {
        "input_ids": input_ids,
        "decoder_input_ids": decoder_input_ids,
        "attention_mask": attention_mask,
        "decoder_attention_mask": attention_mask,
    }




class 			__lowercase     :







     '''simple docstring'''




     def __init__(  self		,     _UpperCAmelCase		,     _UpperCAmelCase=13		,     _UpperCAmelCase=7		,     _UpperCAmelCase=True		,     _UpperCAmelCase=False		,     _UpperCAmelCase=99		,     _UpperCAmelCase=16		,     _UpperCAmelCase=2		,     _UpperCAmelCase=4		,     _UpperCAmelCase=4		,     _UpperCAmelCase="gelu"		,     _UpperCAmelCase=0.1		,     _UpperCAmelCase=0.1		,     _UpperCAmelCase=32		,     _UpperCAmelCase=2		,     _UpperCAmelCase=1		,     _UpperCAmelCase=0		,     _UpperCAmelCase=0.0_2		,     ):
         __a	:  Optional[int]         =					parent
         __a	:  Optional[Any]         =					batch_size
         __a	:  Optional[Any]         =					seq_length
         __a	:  Optional[Any]         =					is_training
         __a	:  Optional[int]         =					use_labels
         __a	:  List[str]         =					vocab_size
         __a	:  List[Any]         =					hidden_size
         __a	:  Dict         =					num_hidden_layers
         __a	:  Dict         =					num_attention_heads
         __a	:  List[Any]         =					intermediate_size
         __a	:  Optional[Any]         =					hidden_act
         __a	:  Any         =					hidden_dropout_prob
         __a	:  Optional[int]         =					attention_probs_dropout_prob
         __a	:  Any         =					max_position_embeddings
         __a	:  Tuple         =					eos_token_id
         __a	:  List[str]         =					pad_token_id
         __a	:  Optional[Any]         =					bos_token_id
         __a	:  Optional[Any]         =					initializer_range







     def 	_lowerCamelCase						(  self       ):
         __a	:  str         =					np.clip(ids_tensor([self.batch_size, self.seq_length - 1]		,     self.vocab_size       )		,     3		,     self.vocab_size       )
         __a	:  List[str]         =					np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1)		,     dtype=np.intaa       ))		,     -1       )

         __a	:  Optional[Any]         =					shift_tokens_right(_UpperCAmelCase		,     1		,     2       )

         __a	:  Optional[Any]         =					BlenderbotConfig(
             vocab_size=self.vocab_size		,     d_model=self.hidden_size		,     encoder_layers=self.num_hidden_layers		,     decoder_layers=self.num_hidden_layers		,     encoder_attention_heads=self.num_attention_heads		,     decoder_attention_heads=self.num_attention_heads		,     encoder_ffn_dim=self.intermediate_size		,     decoder_ffn_dim=self.intermediate_size		,     dropout=self.hidden_dropout_prob		,     attention_dropout=self.attention_probs_dropout_prob		,     max_position_embeddings=self.max_position_embeddings		,     eos_token_id=self.eos_token_id		,     bos_token_id=self.bos_token_id		,     pad_token_id=self.pad_token_id		,     initializer_range=self.initializer_range		,     use_cache=_UpperCAmelCase		,     )
         __a	:  Optional[int]         =					prepare_blenderbot_inputs_dict(_UpperCAmelCase		,     _UpperCAmelCase		,     _UpperCAmelCase       )
         return config, inputs_dict







     def 	_lowerCamelCase						(  self       ):
         __a	:  Dict         =					self.prepare_config_and_inputs()
         return config, inputs_dict







     def 	_lowerCamelCase						(  self		,     _UpperCAmelCase		,     _UpperCAmelCase		,     _UpperCAmelCase       ):
         __a	:  Tuple         =					20
         __a	:  Tuple         =					model_class_name(_UpperCAmelCase       )

         __a	:  List[Any]         =					model.encode(inputs_dict['''input_ids''']       )

         __a	:  int         =					(
             inputs_dict['''decoder_input_ids'''],
             inputs_dict['''decoder_attention_mask'''],
         )

         __a	:  Any         =					model.init_cache(decoder_input_ids.shape[0]		,     _UpperCAmelCase		,     _UpperCAmelCase       )
         __a	:  Optional[Any]         =					jnp.ones((decoder_input_ids.shape[0], max_decoder_length)		,     dtype='''i4'''       )

         __a	:  Union[str, Any]         =					jnp.broadcast_to(
             jnp.arange(decoder_input_ids.shape[-1] - 1       )[None, :]		,     (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)		,     )
         __a	:  Union[str, Any]         =					model.decode(
             decoder_input_ids[:, :-1]		,     _UpperCAmelCase		,     decoder_attention_mask=_UpperCAmelCase		,     past_key_values=_UpperCAmelCase		,     decoder_position_ids=_UpperCAmelCase		,     )

         __a	:  Optional[Any]         =					jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]		,     dtype='''i4'''       )
         __a	:  Any         =					model.decode(
             decoder_input_ids[:, -1:]		,     _UpperCAmelCase		,     decoder_attention_mask=_UpperCAmelCase		,     past_key_values=outputs_cache.past_key_values		,     decoder_position_ids=_UpperCAmelCase		,     )

         __a	:  Union[str, Any]         =					model.decode(_UpperCAmelCase		,     _UpperCAmelCase       )

         __a	:  List[str]         =					np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])       )       )
         self.parent.assertTrue(diff < 1e-3		,     msg=f"""Max diff is {diff}"""       )







     def 	_lowerCamelCase						(  self		,     _UpperCAmelCase		,     _UpperCAmelCase		,     _UpperCAmelCase       ):
         __a	:  List[Any]         =					20
         __a	:  Dict         =					model_class_name(_UpperCAmelCase       )

         __a	:  Dict         =					model.encode(inputs_dict['''input_ids''']       )

         __a	:  Dict         =					(
             inputs_dict['''decoder_input_ids'''],
             inputs_dict['''decoder_attention_mask'''],
         )

         __a	:  int         =					jnp.concatenate(
             [
                 decoder_attention_mask,
                 jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1])       ),
             ]		,     axis=-1		,     )

         __a	:  List[Any]         =					model.init_cache(decoder_input_ids.shape[0]		,     _UpperCAmelCase		,     _UpperCAmelCase       )
         __a	:  List[Any]         =					jnp.broadcast_to(
             jnp.arange(decoder_input_ids.shape[-1] - 1       )[None, :]		,     (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)		,     )

         __a	:  str         =					model.decode(
             decoder_input_ids[:, :-1]		,     _UpperCAmelCase		,     decoder_attention_mask=_UpperCAmelCase		,     past_key_values=_UpperCAmelCase		,     decoder_position_ids=_UpperCAmelCase		,     )
         __a	:  Optional[Any]         =					jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]		,     dtype='''i4'''       )
         __a	:  List[Any]         =					model.decode(
             decoder_input_ids[:, -1:]		,     _UpperCAmelCase		,     past_key_values=outputs_cache.past_key_values		,     decoder_attention_mask=_UpperCAmelCase		,     decoder_position_ids=_UpperCAmelCase		,     )

         __a	:  Dict         =					model.decode(_UpperCAmelCase		,     _UpperCAmelCase		,     decoder_attention_mask=_UpperCAmelCase       )

         __a	:  Optional[Any]         =					np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])       )       )
         self.parent.assertTrue(diff < 1e-3		,     msg=f"""Max diff is {diff}"""       )






@require_flax
class 			__lowercase     (     unittest.TestCase							):







     '''simple docstring'''




     __lowerCAmelCase					=					99







     def 	_lowerCamelCase						(  self       ):
         __a	:  int         =					np.array(
             [
                 [71, 82, 18, 33, 46, 91, 2],
                 [68, 34, 26, 58, 30, 82, 2],
                 [5, 97, 17, 39, 94, 40, 2],
                 [76, 83, 94, 25, 70, 78, 2],
                 [87, 59, 41, 35, 48, 66, 2],
                 [55, 13, 16, 58, 5, 2, 1],  # note padding
                 [64, 27, 31, 51, 12, 75, 2],
                 [52, 64, 86, 17, 83, 39, 2],
                 [48, 61, 9, 24, 71, 82, 2],
                 [26, 1, 60, 48, 22, 13, 2],
                 [21, 5, 62, 28, 14, 76, 2],
                 [45, 98, 37, 86, 59, 48, 2],
                 [70, 70, 50, 9, 28, 0, 2],
             ]		,     dtype=np.intaa		,     )

         __a	:  Any         =					input_ids.shape[0]
         __a	:  List[str]         =					BlenderbotConfig(
             vocab_size=self.vocab_size		,     d_model=24		,     encoder_layers=2		,     decoder_layers=2		,     encoder_attention_heads=2		,     decoder_attention_heads=2		,     encoder_ffn_dim=32		,     decoder_ffn_dim=32		,     max_position_embeddings=48		,     eos_token_id=2		,     pad_token_id=1		,     bos_token_id=0		,     )
         return config, input_ids, batch_size







     def 	_lowerCamelCase						(  self       ):
         __a	:  int         =					self._get_config_and_data()
         __a	:  Optional[int]         =					FlaxBlenderbotForConditionalGeneration(_UpperCAmelCase       )
         __a	:  Any         =					lm_model(input_ids=_UpperCAmelCase       )
         __a	:  List[str]         =					(batch_size, input_ids.shape[1], config.vocab_size)
         self.assertEqual(outputs['''logits'''].shape		,     _UpperCAmelCase       )







     def 	_lowerCamelCase						(  self       ):
         __a	:  Tuple         =					BlenderbotConfig(
             vocab_size=self.vocab_size		,     d_model=14		,     encoder_layers=2		,     decoder_layers=2		,     encoder_attention_heads=2		,     decoder_attention_heads=2		,     encoder_ffn_dim=8		,     decoder_ffn_dim=8		,     max_position_embeddings=48		,     )
         __a	:  Union[str, Any]         =					FlaxBlenderbotForConditionalGeneration(_UpperCAmelCase       )
         __a	:  Tuple         =					np.array([[71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 2, 1]]		,     dtype=np.intaa       )
         __a	:  Optional[Any]         =					np.array([[82, 71, 82, 18, 2], [58, 68, 2, 1, 1]]		,     dtype=np.intaa       )
         __a	:  Tuple         =					lm_model(input_ids=_UpperCAmelCase		,     decoder_input_ids=_UpperCAmelCase       )
         __a	:  str         =					(*summary.shape, config.vocab_size)
         self.assertEqual(outputs['''logits'''].shape		,     _UpperCAmelCase       )







     def 	_lowerCamelCase						(  self       ):
         __a	:  Dict         =					np.array([[71, 82, 18, 33, 2, 1, 1], [68, 34, 26, 58, 30, 82, 2]]		,     dtype=np.intaa       )
         __a	:  List[Any]         =					shift_tokens_right(_UpperCAmelCase		,     1		,     2       )
         __a	:  List[str]         =					np.equal(_UpperCAmelCase		,     1       ).astype(np.floataa       ).sum()
         __a	:  Tuple         =					np.equal(_UpperCAmelCase		,     1       ).astype(np.floataa       ).sum()
         self.assertEqual(shifted.shape		,     input_ids.shape       )
         self.assertEqual(_UpperCAmelCase		,     n_pad_before - 1       )
         self.assertTrue(np.equal(shifted[:, 0]		,     2       ).all()       )






@require_flax
class 			__lowercase     (     _UpperCamelCase				, unittest.TestCase				, _UpperCamelCase							):







     '''simple docstring'''




     __lowerCAmelCase					=					True
     __lowerCAmelCase					=					(
         (
             FlaxBlenderbotModel,
             FlaxBlenderbotForConditionalGeneration,
         )
         if is_flax_available()
         else ()
     )
     __lowerCAmelCase					=					(FlaxBlenderbotForConditionalGeneration,) if is_flax_available() else ()







     def 	_lowerCamelCase						(  self       ):
         __a	:  Dict         =					FlaxBlenderbotModelTester(self       )







     def 	_lowerCamelCase						(  self       ):
         __a	:  int         =					self.model_tester.prepare_config_and_inputs()
         for model_class in self.all_model_classes:
             self.model_tester.check_use_cache_forward(_UpperCAmelCase		,     _UpperCAmelCase		,     _UpperCAmelCase       )







     def 	_lowerCamelCase						(  self       ):
         __a	:  List[Any]         =					self.model_tester.prepare_config_and_inputs()
         for model_class in self.all_model_classes:
             self.model_tester.check_use_cache_forward_with_attn_mask(_UpperCAmelCase		,     _UpperCAmelCase		,     _UpperCAmelCase       )







     def 	_lowerCamelCase						(  self       ):
         __a	:  Dict         =					self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
             with self.subTest(model_class.__name__       ):
                 __a	:  str         =					self._prepare_for_class(_UpperCAmelCase		,     _UpperCAmelCase       )
                 __a	:  Tuple         =					model_class(_UpperCAmelCase       )

                 @jax.jit
                 def encode_jitted(_UpperCAmelCase		,     _UpperCAmelCase=None		,     **_UpperCAmelCase       ):
                     return model.encode(input_ids=_UpperCAmelCase		,     attention_mask=_UpperCAmelCase       )

                 with self.subTest('''JIT Enabled'''       ):
                     __a	:  Optional[Any]         =					encode_jitted(**_UpperCAmelCase       ).to_tuple()

                 with self.subTest('''JIT Disabled'''       ):
                     with jax.disable_jit():
                         __a	:  int         =					encode_jitted(**_UpperCAmelCase       ).to_tuple()

                 self.assertEqual(len(_UpperCAmelCase       )		,     len(_UpperCAmelCase       )       )
                 for jitted_output, output in zip(_UpperCAmelCase		,     _UpperCAmelCase       ):
                     self.assertEqual(jitted_output.shape		,     output.shape       )







     def 	_lowerCamelCase						(  self       ):
         __a	:  List[Any]         =					self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
             with self.subTest(model_class.__name__       ):
                 __a	:  Optional[Any]         =					model_class(_UpperCAmelCase       )
                 __a	:  Any         =					model.encode(inputs_dict['''input_ids''']		,     inputs_dict['''attention_mask''']       )

                 __a	:  Any         =					{
                     '''decoder_input_ids''': inputs_dict['''decoder_input_ids'''],
                     '''decoder_attention_mask''': inputs_dict['''decoder_attention_mask'''],
                     '''encoder_outputs''': encoder_outputs,
                 }

                 @jax.jit
                 def decode_jitted(_UpperCAmelCase		,     _UpperCAmelCase		,     _UpperCAmelCase       ):
                     return model.decode(
                         decoder_input_ids=_UpperCAmelCase		,     decoder_attention_mask=_UpperCAmelCase		,     encoder_outputs=_UpperCAmelCase		,     )

                 with self.subTest('''JIT Enabled'''       ):
                     __a	:  List[Any]         =					decode_jitted(**_UpperCAmelCase       ).to_tuple()

                 with self.subTest('''JIT Disabled'''       ):
                     with jax.disable_jit():
                         __a	:  List[str]         =					decode_jitted(**_UpperCAmelCase       ).to_tuple()

                 self.assertEqual(len(_UpperCAmelCase       )		,     len(_UpperCAmelCase       )       )
                 for jitted_output, output in zip(_UpperCAmelCase		,     _UpperCAmelCase       ):
                     self.assertEqual(jitted_output.shape		,     output.shape       )







     @slow
     def 	_lowerCamelCase						(  self       ):
         for model_class_name in self.all_model_classes:
             __a	:  Tuple         =					model_class_name.from_pretrained('''facebook/blenderbot-400M-distill'''       )
             # FlaxBlenderbotForSequenceClassification expects eos token in input_ids
             __a	:  Optional[int]         =					np.ones((1, 1)       ) * model.config.eos_token_id
             __a	:  Optional[Any]         =					model(_UpperCAmelCase       )
             self.assertIsNotNone(_UpperCAmelCase       )







     @unittest.skipUnless(jax_device != '''cpu'''		,     '''3B test too slow on CPU.'''       )
     @slow
     def 	_lowerCamelCase						(  self       ):
         __a	:  Tuple         =					{'''num_beams''': 1, '''early_stopping''': True, '''min_length''': 15, '''max_length''': 25}
         __a	:  Optional[Any]         =					{'''skip_special_tokens''': True, '''clean_up_tokenization_spaces''': True}

         __a	:  str         =					FlaxBlenderbotForConditionalGeneration.from_pretrained('''facebook/blenderbot-3B'''		,     from_pt=_UpperCAmelCase       )
         __a	:  Union[str, Any]         =					BlenderbotTokenizer.from_pretrained('''facebook/blenderbot-3B'''       )

         __a	:  Tuple         =					['''Sam''']
         __a	:  str         =					tokenizer(_UpperCAmelCase		,     return_tensors='''jax'''       )

         __a	:  Tuple         =					model.generate(**_UpperCAmelCase		,     **_UpperCAmelCase       )
         __a	:  List[Any]         =					'''Sam is a great name. It means "sun" in Gaelic.'''

         __a	:  List[str]         =					tokenizer.batch_decode(_UpperCAmelCase		,     **_UpperCAmelCase       )
         assert generated_txt[0].strip() == tgt_text






"""simple docstring"""






import comet  # From: unbabel-comet
import torch

import datasets


A	     =					datasets.logging.get_logger(__name__)

A	     =					'''\
@inproceedings{rei-EtAl:2020:WMT,
   author    = {Rei, Ricardo  and  Stewart, Craig  and  Farinha, Ana C  and  Lavie, Alon},
   title     = {Unbabel\'s Participation in the WMT20 Metrics Shared Task},
   booktitle      = {Proceedings of the Fifth Conference on Machine Translation},
   month          = {November},
   year           = {2020},
   address        = {Online},
   publisher      = {Association for Computational Linguistics},
   pages     = {909--918},
}
@inproceedings{rei-etal-2020-comet,
   title = "{COMET}: A Neural Framework for {MT} Evaluation",
   author = "Rei, Ricardo  and
      Stewart, Craig  and
      Farinha, Ana C  and
      Lavie, Alon",
   booktitle = "Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP)",
   month = nov,
   year = "2020",
   address = "Online",
   publisher = "Association for Computational Linguistics",
   url = "https://www.aclweb.org/anthology/2020.emnlp-main.213",
   pages = "2685--2702",
}
'''

A	     =					'''\
Crosslingual Optimized Metric for Evaluation of Translation (COMET) is an open-source framework used to train Machine Translation metrics that achieve high levels of correlation with different types of human judgments (HTER, DA\'s or MQM).
With the release of the framework the authors also released fully trained models that were used to compete in the WMT20 Metrics Shared Task achieving SOTA in that years competition.

See the [README.md] file at https://unbabel.github.io/COMET/html/models.html for more information.
'''

A	     =					'''
COMET score.

Args:

`sources` (list of str): Source sentences
`predictions` (list of str): candidate translations
`references` (list of str): reference translations
`cuda` (bool): If set to True, runs COMET using GPU
`show_progress` (bool): Shows progress
`model`: COMET model to be used. Will default to `wmt-large-da-estimator-1719` if None.

Returns:
    `samples`: List of dictionaries with `src`, `mt`, `ref` and `score`.
    `scores`: List of scores.

Examples:

    >>> comet_metric = datasets.load_metric(\'comet\')
    >>> # comet_metric = load_metric(\'comet\', \'wmt20-comet-da\')  # you can also choose which model to use
    >>> source = ["Dem Feuer konnte Einhalt geboten werden", "Schulen und Kindergärten wurden eröffnet."]
    >>> hypothesis = ["The fire could be stopped", "Schools and kindergartens were open"]
    >>> reference = ["They were able to control the fire.", "Schools and kindergartens opened"]
    >>> results = comet_metric.compute(predictions=hypothesis, references=reference, sources=source)
    >>> print([round(v, 2) for v in results["scores"]])
    [0.19, 0.92]
'''




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







					'''simple docstring'''




					def 	_lowerCamelCase						(  self       ):
									return datasets.MetricInfo(
									    description=_DESCRIPTION		,     citation=_CITATION		,     homepage='''https://unbabel.github.io/COMET/html/index.html'''		,     inputs_description=_KWARGS_DESCRIPTION		,     features=datasets.Features(
									        {
									            '''sources''': datasets.Value('''string'''		,     id='''sequence'''       ),
									            '''predictions''': datasets.Value('''string'''		,     id='''sequence'''       ),
									            '''references''': datasets.Value('''string'''		,     id='''sequence'''       ),
									        }       )		,     codebase_urls=['''https://github.com/Unbabel/COMET''']		,     reference_urls=[
									        '''https://github.com/Unbabel/COMET''',
									        '''https://www.aclweb.org/anthology/2020.emnlp-main.213/''',
									        '''http://www.statmt.org/wmt20/pdf/2020.wmt-1.101.pdf6''',
									    ]		,     )







					def 	_lowerCamelCase						(  self		,     _UpperCAmelCase       ):
									if self.config_name == "default":
													__a	:  List[str]         =					comet.load_from_checkpoint(comet.download_model('''wmt20-comet-da'''       )       )
									else:
													__a	:  List[str]         =					comet.load_from_checkpoint(comet.download_model(self.config_name       )       )







					def 	_lowerCamelCase						(  self		,     _UpperCAmelCase		,     _UpperCAmelCase		,     _UpperCAmelCase		,     _UpperCAmelCase=None		,     _UpperCAmelCase=False       ):
									if gpus is None:
													__a	:  str         =					1 if torch.cuda.is_available() else 0
									__a	:  Optional[Any]         =					{'''src''': sources, '''mt''': predictions, '''ref''': references}
									__a	:  Dict         =					[dict(zip(_UpperCAmelCase		,     _UpperCAmelCase       )       ) for t in zip(*data.values()       )]
									__a    ,  __a	:  int         =					self.scorer.predict(_UpperCAmelCase		,     gpus=_UpperCAmelCase		,     progress_bar=_UpperCAmelCase       )
									return {"mean_score": mean_score, "scores": scores}