


import comet  # From: unbabel-comet
import torch

import datasets


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

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

_SCREAMING_SNAKE_CASE     :					str      =       "\\nCrosslingual 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).\nWith 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.\n\nSee the [README.md] file at https://unbabel.github.io/COMET/html/models.html for more information.\n"

_SCREAMING_SNAKE_CASE     :					Any      =       "\nCOMET score.\n\nArgs:\n\n`sources` (list of str): Source sentences\n`predictions` (list of str): candidate translations\n`references` (list of str): reference translations\n`cuda` (bool): If set to True, runs COMET using GPU\n`show_progress` (bool): Shows progress\n`model`: COMET model to be used. Will default to `wmt-large-da-estimator-1719` if None.\n\nReturns:\n    `samples`: List of dictionaries with `src`, `mt`, `ref` and `score`.\n    `scores`: List of scores.\n\nExamples:\n\n    >>> comet_metric = datasets.load_metric('comet')\n    >>> # comet_metric = load_metric('comet', 'wmt20-comet-da')  # you can also choose which model to use\n    >>> source = [\"Dem Feuer konnte Einhalt geboten werden\", \"Schulen und Kindergärten wurden eröffnet.\"]\n    >>> hypothesis = [\"The fire could be stopped\", \"Schools and kindergartens were open\"]\n    >>> reference = [\"They were able to control the fire.\", \"Schools and kindergartens opened\"]\n    >>> results = comet_metric.compute(predictions=hypothesis, references=reference, sources=source)\n    >>> print([round(v, 2) for v in results[\"scores\"]])\n    [0.19, 0.92]\n"

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







    """simple docstring"""

    def 						a_     (			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 						a_     (			self     ,   __snake_case       ):
         if self.config_name == "default":
              snake_case											=							comet.load_from_checkpoint(comet.download_model('''wmt20-comet-da'''       )       )
         else:
              snake_case											=							comet.load_from_checkpoint(comet.download_model(self.config_name       )       )




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








from __future__ import annotations

import random
import unittest

from transformers import TransfoXLConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
 import tensorflow as tf

 from transformers import (
     TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
     TFTransfoXLForSequenceClassification,
     TFTransfoXLLMHeadModel,
     TFTransfoXLModel,
 )

class     A__   :







    """simple docstring"""

    def __init__(			self     ,   __snake_case     ,   ):
         snake_case											=							parent
         snake_case											=							1_3
         snake_case											=							7
         snake_case											=							3_0
         snake_case											=							self.seq_length + self.mem_len
         snake_case											=							1_5
         snake_case											=							True
         snake_case											=							True
         snake_case											=							9_9
         snake_case											=							[1_0, 5_0, 8_0]
         snake_case											=							3_2
         snake_case											=							3_2
         snake_case											=							4
         snake_case											=							8
         snake_case											=							1_2_8
         snake_case											=							2
         snake_case											=							2
         snake_case											=							None
         snake_case											=							1
         snake_case											=							0
         snake_case											=							3
         snake_case											=							self.vocab_size - 1
         snake_case											=							0.01
    def 						a_     (			self       ):
         snake_case											=							ids_tensor([self.batch_size, self.seq_length]     ,   self.vocab_size       )
         snake_case											=							ids_tensor([self.batch_size, self.seq_length]     ,   self.vocab_size       )

         snake_case											=							None
         if self.use_labels:
              snake_case											=							ids_tensor([self.batch_size, self.seq_length]     ,   self.vocab_size       )

         snake_case											=							TransfoXLConfig(
             vocab_size=self.vocab_size     ,   mem_len=self.mem_len     ,   clamp_len=self.clamp_len     ,   cutoffs=self.cutoffs     ,   d_model=self.hidden_size     ,   d_embed=self.d_embed     ,   n_head=self.num_attention_heads     ,   d_head=self.d_head     ,   d_inner=self.d_inner     ,   div_val=self.div_val     ,   n_layer=self.num_hidden_layers     ,   eos_token_id=self.eos_token_id     ,   pad_token_id=self.vocab_size - 1     ,   init_range=self.init_range     ,   num_labels=self.num_labels     ,   )

         return (config, input_ids_a, input_ids_a, lm_labels)
    def 						a_     (			self       ):
         random.seed(self.seed       )
         tf.random.set_seed(self.seed       )
    def 						a_     (			self     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case       ):
         snake_case											=							TFTransfoXLModel(__snake_case       )

         snake_case					,    snake_case											=							model(__snake_case       ).to_tuple()

         snake_case											=							{'''input_ids''': input_ids_a, '''mems''': mems_a}

         snake_case					,    snake_case											=							model(__snake_case       ).to_tuple()

         self.parent.assertEqual(hidden_states_a.shape     ,   (self.batch_size, self.seq_length, self.hidden_size)       )
         self.parent.assertEqual(hidden_states_a.shape     ,   (self.batch_size, self.seq_length, self.hidden_size)       )
         self.parent.assertListEqual(
             [mem.shape for mem in mems_a]     ,   [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers     ,   )
         self.parent.assertListEqual(
             [mem.shape for mem in mems_a]     ,   [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers     ,   )
    def 						a_     (			self     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case       ):
         snake_case											=							TFTransfoXLLMHeadModel(__snake_case       )

         snake_case					,    snake_case											=							model(__snake_case       ).to_tuple()

         snake_case											=							{'''input_ids''': input_ids_a, '''labels''': lm_labels}
         snake_case					,    snake_case											=							model(__snake_case       ).to_tuple()

         snake_case					,    snake_case											=							model([input_ids_a, mems_a]       ).to_tuple()

         snake_case											=							{'''input_ids''': input_ids_a, '''mems''': mems_a, '''labels''': lm_labels}

         snake_case					,    snake_case											=							model(__snake_case       ).to_tuple()

         self.parent.assertEqual(lm_logits_a.shape     ,   (self.batch_size, self.seq_length, self.vocab_size)       )
         self.parent.assertListEqual(
             [mem.shape for mem in mems_a]     ,   [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers     ,   )

         self.parent.assertEqual(lm_logits_a.shape     ,   (self.batch_size, self.seq_length, self.vocab_size)       )
         self.parent.assertListEqual(
             [mem.shape for mem in mems_a]     ,   [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers     ,   )
    def 						a_     (			self     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case       ):
         snake_case											=							TFTransfoXLForSequenceClassification(__snake_case       )
         snake_case											=							model(__snake_case       )
         self.parent.assertEqual(result.logits.shape     ,   (self.batch_size, self.num_labels)       )




    def 						a_     (			self       ):
         snake_case											=							self.prepare_config_and_inputs()
         ((snake_case)					,    (snake_case)					,    (snake_case)					,    (snake_case))											=							config_and_inputs
         snake_case											=							{'''input_ids''': input_ids_a}
         return config, inputs_dict






@require_tf
class     A__   (       snake_case__			,   snake_case__			,   unittest.TestCase      ):







    """simple docstring"""

    __magic_name__         =						(
        (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
    )
    __magic_name__         =						() if is_tf_available() else ()
    __magic_name__         =						(
        {
            'feature-extraction': TFTransfoXLModel,
            'text-classification': TFTransfoXLForSequenceClassification,
            'text-generation': TFTransfoXLLMHeadModel,
            'zero-shot': TFTransfoXLForSequenceClassification,
        }
        if is_tf_available()
        else {}
    )
    # TODO: add this test when TFTransfoXLLMHead has a linear output layer implemented
    __magic_name__         =						False
    __magic_name__         =						False
    __magic_name__         =						False
    __magic_name__         =						False
    def 						a_     (			self     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case       ):
         if pipeline_test_casse_name == "TextGenerationPipelineTests":
              # Get `ValueError: AttributeError: 'NoneType' object has no attribute 'new_ones'` or `AssertionError`.
              # `TransfoXLConfig` was never used in pipeline tests: cannot create a simple
              # tokenizer.
              return True

         return False
    def 						a_     (			self       ):
         snake_case											=							TFTransfoXLModelTester(self       )
         snake_case											=							ConfigTester(self     ,   config_class=__snake_case     ,   d_embed=3_7       )
    def 						a_     (			self       ):
         self.config_tester.run_common_tests()
    def 						a_     (			self       ):
         self.model_tester.set_seed()
         snake_case											=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_model(*__snake_case       )
    def 						a_     (			self       ):
         self.model_tester.set_seed()
         snake_case											=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_lm_head(*__snake_case       )
    def 						a_     (			self       ):
         snake_case											=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*__snake_case       )
    def 						a_     (			self       ):
         snake_case					,    snake_case											=							self.model_tester.prepare_config_and_inputs_for_common()
         snake_case											=							[TFTransfoXLForSequenceClassification]

         for model_class in self.all_model_classes:
              snake_case											=							model_class(__snake_case       )
              assert isinstance(model.get_input_embeddings()     ,   tf.keras.layers.Layer       )
              if model_class in list_other_models_with_output_ebd:
                   snake_case											=							model.get_output_embeddings()
                   assert isinstance(__snake_case     ,   tf.keras.layers.Layer       )
                   snake_case											=							model.get_bias()
                   assert name is None
              else:
                   snake_case											=							model.get_output_embeddings()
                   assert x is None
                   snake_case											=							model.get_bias()
                   assert name is None
    def 						a_     (			self       ):
         # TODO JP: Make TransfoXL XLA compliant
         pass
    @slow
    def 						a_     (			self       ):
         for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              snake_case											=							TFTransfoXLModel.from_pretrained(__snake_case       )
              self.assertIsNotNone(__snake_case       )




    @unittest.skip(reason='''This model doesn\'t play well with fit() due to not returning a single loss.'''       )
    def 						a_     (			self       ):
         pass






@require_tf
class     A__   (       unittest.TestCase      ):







    """simple docstring"""

    @unittest.skip('''Skip test until #12651 is resolved.'''       )
    @slow
    def 						a_     (			self       ):
         snake_case											=							TFTransfoXLLMHeadModel.from_pretrained('''transfo-xl-wt103'''       )
         # fmt: off
         snake_case											=							tf.convert_to_tensor([[3_3,1_2_9_7,2,1,1_0_0_9,4,1_1_0_9,1_1_7_3_9,4_7_6_2,3_5_8,5,2_5,2_4_5,2_2,1_7_0_6,1_7,2_0_0_9_8,5,3_2_1_5,2_1,3_7,1_1_1_0,3,1_3,1_0_4_1,4,2_4,6_0_3,4_9_0,2,7_1_4_7_7,2_0_0_9_8,1_0_4_4_4_7,2,2_0_9_6_1,1,2_6_0_4,4,1,3_2_9,3,6_2_2_4,8_3_1,1_6_0_0_2,2,8,6_0_3,7_8_9_6_7,2_9_5_4_6,2_3,8_0_3,2_0,2_5,4_1_6,5,8,2_3_2,4,2_7_7,6,1_8_5_5,4_6_0_1,3,2_9_5_4_6,5_4,8,3_6_0_9,5,5_7_2_1_1,4_9,4,1,2_7_7,1_8,8,1_7_5_5,1_5_6_9_1,3,3_4_1,2_5,4_1_6,6_9_3,4_2_5_7_3,7_1,1_7,4_0_1,9_4,3_1,1_7_9_1_9,2,2_9_5_4_6,7_8_7_3,1_8,1,4_3_5,2_3,1_1_0_1_1,7_5_5,5,5_1_6_7,3,7_9_8_3,9_8,8_4,2,2_9_5_4_6,3_2_6_7,8,3_6_0_9,4,1,4_8_6_5,1_0_7_5,2,6_0_8_7,7_1,6,3_4_6,8,5_8_5_4,3,2_9_5_4_6,8_2_4,1_4_0_0,1_8_6_8,2,1_9,1_6_0,2,3_1_1,8,5_4_9_6,2,2_0_9_2_0,1_7,2_5,1_5_0_9_7,3,2_4,2_4,0]]     ,   dtype=tf.intaa       )  # noqa: E231
         # fmt: on
         #  In 1991 , the remains of Russian Tsar Nicholas II and his family
         #  ( except for Alexei and Maria ) are discovered .
         #  The voice of Nicholas's young son , Tsarevich Alexei Nikolaevich , narrates the
         #  remainder of the story . 1883 Western Siberia ,
         #  a young Grigori Rasputin is asked by his father and a group of men to perform magic .
         #  Rasputin has a vision and denounces one of the men as a horse thief . Although his
         #  father initially slaps him for making such an accusation , Rasputin watches as the
         #  man is chased outside and beaten . Twenty years later , Rasputin sees a vision of
         #  the Virgin Mary , prompting him to become a priest . Rasputin quickly becomes famous ,
         #  with people , even a bishop , begging for his blessing . <eod> </s> <eos>

         # fmt: off
         snake_case											=							[3_3,1_2_9_7,2,1,1_0_0_9,4,1_1_0_9,1_1_7_3_9,4_7_6_2,3_5_8,5,2_5,2_4_5,2_2,1_7_0_6,1_7,2_0_0_9_8,5,3_2_1_5,2_1,3_7,1_1_1_0,3,1_3,1_0_4_1,4,2_4,6_0_3,4_9_0,2,7_1_4_7_7,2_0_0_9_8,1_0_4_4_4_7,2,2_0_9_6_1,1,2_6_0_4,4,1,3_2_9,3,6_2_2_4,8_3_1,1_6_0_0_2,2,8,6_0_3,7_8_9_6_7,2_9_5_4_6,2_3,8_0_3,2_0,2_5,4_1_6,5,8,2_3_2,4,2_7_7,6,1_8_5_5,4_6_0_1,3,2_9_5_4_6,5_4,8,3_6_0_9,5,5_7_2_1_1,4_9,4,1,2_7_7,1_8,8,1_7_5_5,1_5_6_9_1,3,3_4_1,2_5,4_1_6,6_9_3,4_2_5_7_3,7_1,1_7,4_0_1,9_4,3_1,1_7_9_1_9,2,2_9_5_4_6,7_8_7_3,1_8,1,4_3_5,2_3,1_1_0_1_1,7_5_5,5,5_1_6_7,3,7_9_8_3,9_8,8_4,2,2_9_5_4_6,3_2_6_7,8,3_6_0_9,4,1,4_8_6_5,1_0_7_5,2,6_0_8_7,7_1,6,3_4_6,8,5_8_5_4,3,2_9_5_4_6,8_2_4,1_4_0_0,1_8_6_8,2,1_9,1_6_0,2,3_1_1,8,5_4_9_6,2,2_0_9_2_0,1_7,2_5,1_5_0_9_7,3,2_4,2_4,0,3_3,1,1_8_5_7,2,1,1_0_0_9,4,1_1_0_9,1_1_7_3_9,4_7_6_2,3_5_8,5,2_5,2_4_5,2_8,1_1_1_0,3,1_3,1_0_4_1,4,2_4,6_0_3,4_9_0,2,7_1_4_7_7,2_0_0_9_8,1_0_4_4_4_7,2,2_0_9_6_1,1,2_6_0_4,4,1,3_2_9,3,0]  # noqa: E231
         # fmt: on
         #  In 1991, the remains of Russian Tsar Nicholas II and his family (
         #  except for Alexei and Maria ) are discovered. The voice of young son,
         #  Tsarevich Alexei Nikolaevich, narrates the remainder of the story.
         #  1883 Western Siberia, a young Grigori Rasputin is asked by his father
         #  and a group of men to perform magic. Rasputin has a vision and
         #  denounces one of the men as a horse thief. Although his father initially
         #  slaps him for making such an accusation, Rasputin watches as the man
         #  is chased outside and beaten. Twenty years later, Rasputin sees a vision
         #  of the Virgin Mary, prompting him to become a priest.
         #  Rasputin quickly becomes famous, with people, even a bishop, begging for
         #  his blessing. <unk> <unk> <eos> In the 1990s, the remains of Russian Tsar
         # Nicholas II and his family were discovered. The voice of <unk> young son,
         # Tsarevich Alexei Nikolaevich, narrates the remainder of the story.<eos>

         snake_case											=							model.generate(__snake_case     ,   max_length=2_0_0     ,   do_sample=__snake_case       )
         self.assertListEqual(output_ids[0].numpy().tolist()     ,   __snake_case       )




