code: 
  
  
  
  
  
  
  from __future__ import annotations
  
  import unittest
  
  from transformers import 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, random_attention_mask
  from ...test_pipeline_mixin import PipelineTesterMixin
  
  
  if is_tf_available():
  	import tensorflow as tf
  
  	from transformers import (
  	    TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
  	    TFXLMForMultipleChoice,
  	    TFXLMForQuestionAnsweringSimple,
  	    TFXLMForSequenceClassification,
  	    TFXLMForTokenClassification,
  	    TFXLMModel,
  	    TFXLMWithLMHeadModel,
  	    XLMConfig,
  	)
  
  
  
  
  
  
  
  class     UpperCAmelCase_		:
  
  
  
  						"""simple docstring"""
  						def __init__(       self					,       SCREAMING_SNAKE_CASE_					,       )       ->   str:
  										UpperCamelCase :Tuple										=     parent
  										UpperCamelCase :Dict										=     13
  										UpperCamelCase :List[str]										=     7
  										UpperCamelCase :Tuple										=     True
  										UpperCamelCase :str										=     True
  										UpperCamelCase :List[Any]										=     True
  										UpperCamelCase :Tuple										=     True
  										UpperCamelCase :List[str]										=     True
  										UpperCamelCase :Optional[int]										=     False
  										UpperCamelCase :List[Any]										=     False
  										UpperCamelCase :int										=     False
  										UpperCamelCase :List[str]										=     2
  										UpperCamelCase :Dict										=     99
  										UpperCamelCase :List[Any]										=     0
  										UpperCamelCase :Tuple										=     32
  										UpperCamelCase :List[Any]										=     2
  										UpperCamelCase :Tuple										=     4
  										UpperCamelCase :List[Any]										=     0.1
  										UpperCamelCase :str										=     0.1
  										UpperCamelCase :Tuple										=     512
  										UpperCamelCase :Dict										=     16
  										UpperCamelCase :Tuple										=     2
  										UpperCamelCase :Optional[Any]										=     0.02
  										UpperCamelCase :int										=     3
  										UpperCamelCase :int										=     4
  										UpperCamelCase :Any										=     '''last'''
  										UpperCamelCase :Dict										=     True
  										UpperCamelCase :Dict										=     None
  										UpperCamelCase :str										=     0
  						def 					UpperCAmelCase		(       self				)       ->   Dict:
  										UpperCamelCase :Union[str, Any]										=     ids_tensor([self.batch_size, self.seq_length]					,       self.vocab_size				)
  										UpperCamelCase :Any										=     random_attention_mask([self.batch_size, self.seq_length]					,       dtype=tf.floataa				)
  
  										UpperCamelCase :List[str]										=     None
  										if self.use_input_lengths:
  														UpperCamelCase :Optional[int]										=     (
  														    ids_tensor([self.batch_size]					,       vocab_size=2				) + self.seq_length - 2
  														)  # small variation of seq_length
  
  										UpperCamelCase :Union[str, Any]										=     None
  										if self.use_token_type_ids:
  														UpperCamelCase :Dict										=     ids_tensor([self.batch_size, self.seq_length]					,       self.n_langs				)
  
  										UpperCamelCase :Union[str, Any]										=     None
  										UpperCamelCase :Optional[int]										=     None
  										UpperCamelCase :Dict										=     None
  										if self.use_labels:
  														UpperCamelCase :Any										=     ids_tensor([self.batch_size]					,       self.type_sequence_label_size				)
  														UpperCamelCase :Optional[int]										=     ids_tensor([self.batch_size, self.seq_length]					,       self.num_labels				)
  														UpperCamelCase :Union[str, Any]										=     ids_tensor([self.batch_size]					,       2					,       dtype=tf.floataa				)
  														UpperCamelCase :List[Any]										=     ids_tensor([self.batch_size]					,       self.num_choices				)
  
  										UpperCamelCase :Tuple										=     XLMConfig(
  										    vocab_size=self.vocab_size					,       n_special=self.n_special					,       emb_dim=self.hidden_size					,       n_layers=self.num_hidden_layers					,       n_heads=self.num_attention_heads					,       dropout=self.hidden_dropout_prob					,       attention_dropout=self.attention_probs_dropout_prob					,       gelu_activation=self.gelu_activation					,       sinusoidal_embeddings=self.sinusoidal_embeddings					,       asm=self.asm					,       causal=self.causal					,       n_langs=self.n_langs					,       max_position_embeddings=self.max_position_embeddings					,       initializer_range=self.initializer_range					,       summary_type=self.summary_type					,       use_proj=self.use_proj					,       bos_token_id=self.bos_token_id					,       )
  
  										return (
  										    config,
  										    input_ids,
  										    token_type_ids,
  										    input_lengths,
  										    sequence_labels,
  										    token_labels,
  										    is_impossible_labels,
  										    choice_labels,
  										    input_mask,
  										)
  						def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       )       ->   Union[str, Any]:
  										UpperCamelCase :Union[str, Any]										=     TFXLMModel(config=SCREAMING_SNAKE_CASE_				)
  										UpperCamelCase :Dict										=     {'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
  										UpperCamelCase :Optional[Any]										=     model(SCREAMING_SNAKE_CASE_				)
  
  										UpperCamelCase :Optional[int]										=     [input_ids, input_mask]
  										UpperCamelCase :str										=     model(SCREAMING_SNAKE_CASE_				)
  										self.parent.assertEqual(result.last_hidden_state.shape					,       (self.batch_size, self.seq_length, self.hidden_size)				)
  						def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       )       ->   List[Any]:
  										UpperCamelCase :Any										=     TFXLMWithLMHeadModel(SCREAMING_SNAKE_CASE_				)
  
  										UpperCamelCase :Optional[int]										=     {'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
  										UpperCamelCase :Dict										=     model(SCREAMING_SNAKE_CASE_				)
  
  										UpperCamelCase :Dict										=     outputs
  
  										self.parent.assertEqual(result.logits.shape					,       (self.batch_size, self.seq_length, self.vocab_size)				)
  						def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       )       ->   Tuple:
  										UpperCamelCase :Optional[int]										=     TFXLMForQuestionAnsweringSimple(SCREAMING_SNAKE_CASE_				)
  
  										UpperCamelCase :Optional[Any]										=     {'''input_ids''': input_ids, '''lengths''': input_lengths}
  
  										UpperCamelCase :str										=     model(SCREAMING_SNAKE_CASE_				)
  
  										self.parent.assertEqual(result.start_logits.shape					,       (self.batch_size, self.seq_length)				)
  										self.parent.assertEqual(result.end_logits.shape					,       (self.batch_size, self.seq_length)				)
  						def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       )       ->   Optional[Any]:
  										UpperCamelCase :Tuple										=     TFXLMForSequenceClassification(SCREAMING_SNAKE_CASE_				)
  
  										UpperCamelCase :List[Any]										=     {'''input_ids''': input_ids, '''lengths''': input_lengths}
  
  										UpperCamelCase :Optional[Any]										=     model(SCREAMING_SNAKE_CASE_				)
  
  										self.parent.assertEqual(result.logits.shape					,       (self.batch_size, self.type_sequence_label_size)				)
  						def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       )       ->   List[str]:
  										UpperCamelCase :Union[str, Any]										=     self.num_labels
  										UpperCamelCase :Any										=     TFXLMForTokenClassification(config=SCREAMING_SNAKE_CASE_				)
  										UpperCamelCase :int										=     {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
  										UpperCamelCase :int										=     model(SCREAMING_SNAKE_CASE_				)
  										self.parent.assertEqual(result.logits.shape					,       (self.batch_size, self.seq_length, self.num_labels)				)
  						def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       )       ->   str:
  										UpperCamelCase :Optional[Any]										=     self.num_choices
  										UpperCamelCase :int										=     TFXLMForMultipleChoice(config=SCREAMING_SNAKE_CASE_				)
  										UpperCamelCase :Tuple										=     tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE_					,       1				)					,       (1, self.num_choices, 1)				)
  										UpperCamelCase :int										=     tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE_					,       1				)					,       (1, self.num_choices, 1)				)
  										UpperCamelCase :Union[str, Any]										=     tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE_					,       1				)					,       (1, self.num_choices, 1)				)
  										UpperCamelCase :List[str]										=     {
  										    '''input_ids''': multiple_choice_inputs_ids,
  										    '''attention_mask''': multiple_choice_input_mask,
  										    '''token_type_ids''': multiple_choice_token_type_ids,
  										}
  										UpperCamelCase :Any										=     model(SCREAMING_SNAKE_CASE_				)
  										self.parent.assertEqual(result.logits.shape					,       (self.batch_size, self.num_choices)				)
  
  
  
  
  						def 					UpperCAmelCase		(       self				)       ->   Optional[int]:
  										UpperCamelCase :Dict										=     self.prepare_config_and_inputs()
  										(
  										    UpperCamelCase     
  										) :Optional[int]										=     config_and_inputs
  										UpperCamelCase :Dict										=     {
  										    '''input_ids''': input_ids,
  										    '''token_type_ids''': token_type_ids,
  										    '''langs''': token_type_ids,
  										    '''lengths''': input_lengths,
  										}
  										return config, inputs_dict
  
  
  
  
  
  
  
  @require_tf
  class     UpperCAmelCase_		(      lowercase,			lowercase,			unittest.TestCase				):
  
  
  
  						"""simple docstring"""
  						UpperCamelCase_       :      int     =(
  						    (
  						        TFXLMModel,
  						        TFXLMWithLMHeadModel,
  						        TFXLMForSequenceClassification,
  						        TFXLMForQuestionAnsweringSimple,
  						        TFXLMForTokenClassification,
  						        TFXLMForMultipleChoice,
  						    )
  						    if is_tf_available()
  						    else ()
  						)
  						UpperCamelCase_       :      Dict     =(
  						    (TFXLMWithLMHeadModel,) if is_tf_available() else ()
  						)  # TODO (PVP): Check other models whether language generation is also applicable
  						UpperCamelCase_       :      List[Any]     =(
  						    {
  						        'feature-extraction': TFXLMModel,
  						        'fill-mask': TFXLMWithLMHeadModel,
  						        'question-answering': TFXLMForQuestionAnsweringSimple,
  						        'text-classification': TFXLMForSequenceClassification,
  						        'text-generation': TFXLMWithLMHeadModel,
  						        'token-classification': TFXLMForTokenClassification,
  						        'zero-shot': TFXLMForSequenceClassification,
  						    }
  						    if is_tf_available()
  						    else {}
  						)
  						UpperCamelCase_       :      List[str]     =False
  						UpperCamelCase_       :      Union[str, Any]     =False
  						def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)       ->   Dict:
  										if (
  										    pipeline_test_casse_name == "QAPipelineTests"
  										    and tokenizer_name is not None
  										    and not tokenizer_name.endswith('''Fast'''				)
  										):
  														# `QAPipelineTests` fails for a few models when the slower tokenizer are used.
  														# (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
  														# TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
  														return True
  
  										return False
  						def 					UpperCAmelCase		(       self				)       ->   Optional[Any]:
  										UpperCamelCase :Union[str, Any]										=     TFXLMModelTester(self				)
  										UpperCamelCase :int										=     ConfigTester(self					,       config_class=SCREAMING_SNAKE_CASE_					,       emb_dim=37				)
  						def 					UpperCAmelCase		(       self				)       ->   Optional[Any]:
  										self.config_tester.run_common_tests()
  						def 					UpperCAmelCase		(       self				)       ->   Any:
  										UpperCamelCase :List[str]										=     self.model_tester.prepare_config_and_inputs()
  										self.model_tester.create_and_check_xlm_model(*SCREAMING_SNAKE_CASE_				)
  						def 					UpperCAmelCase		(       self				)       ->   Any:
  										UpperCamelCase :Tuple										=     self.model_tester.prepare_config_and_inputs()
  										self.model_tester.create_and_check_xlm_lm_head(*SCREAMING_SNAKE_CASE_				)
  						def 					UpperCAmelCase		(       self				)       ->   List[Any]:
  										UpperCamelCase :int										=     self.model_tester.prepare_config_and_inputs()
  										self.model_tester.create_and_check_xlm_qa(*SCREAMING_SNAKE_CASE_				)
  						def 					UpperCAmelCase		(       self				)       ->   Union[str, Any]:
  										UpperCamelCase :Union[str, Any]										=     self.model_tester.prepare_config_and_inputs()
  										self.model_tester.create_and_check_xlm_sequence_classif(*SCREAMING_SNAKE_CASE_				)
  						def 					UpperCAmelCase		(       self				)       ->   List[Any]:
  										UpperCamelCase :Tuple										=     self.model_tester.prepare_config_and_inputs()
  										self.model_tester.create_and_check_xlm_for_token_classification(*SCREAMING_SNAKE_CASE_				)
  						def 					UpperCAmelCase		(       self				)       ->   Optional[Any]:
  										UpperCamelCase :Tuple										=     self.model_tester.prepare_config_and_inputs()
  										self.model_tester.create_and_check_xlm_for_multiple_choice(*SCREAMING_SNAKE_CASE_				)
  
  
  
  
  						@slow
  						def 					UpperCAmelCase		(       self				)       ->   Optional[Any]:
  										for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
  														UpperCamelCase :List[str]										=     TFXLMModel.from_pretrained(SCREAMING_SNAKE_CASE_				)
  														self.assertIsNotNone(SCREAMING_SNAKE_CASE_				)
  
  
  
  
  
  
  
  @require_tf
  class     UpperCAmelCase_		(      unittest.TestCase				):
  
  
  
  						"""simple docstring"""
  						@slow
  						def 					UpperCAmelCase		(       self				)       ->   int:
  										UpperCamelCase :Tuple										=     TFXLMWithLMHeadModel.from_pretrained('''xlm-mlm-en-2048'''				)
  										UpperCamelCase :Optional[int]										=     tf.convert_to_tensor([[14, 447]]					,       dtype=tf.intaa				)  # the president
  										UpperCamelCase :Optional[int]										=     [
  										    14,
  										    447,
  										    14,
  										    447,
  										    14,
  										    447,
  										    14,
  										    447,
  										    14,
  										    447,
  										    14,
  										    447,
  										    14,
  										    447,
  										    14,
  										    447,
  										    14,
  										    447,
  										    14,
  										    447,
  										]  # the president the president the president the president the president the president the president the president the president the president
  										# TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
  										UpperCamelCase :List[str]										=     model.generate(SCREAMING_SNAKE_CASE_					,       do_sample=SCREAMING_SNAKE_CASE_				)
  										self.assertListEqual(output_ids[0].numpy().tolist()					,       SCREAMING_SNAKE_CASE_				)
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  # as due to their complexity multi-gpu tests could impact other tests, and to aid debug we have those in a separate module.
  
  import os
  import sys
  
  from transformers.testing_utils import TestCasePlus, execute_subprocess_async, get_gpu_count, require_torch_gpu, slow
  
  from .utils import load_json
  
  
  
  
  
  
  
  class     UpperCAmelCase_		(      lowercase				):
  
  
  
        """simple docstring"""
        @classmethod
        def 					UpperCAmelCase		(       cls				)       ->   List[Any]:
            return cls
  
  
  
  
        @slow
        @require_torch_gpu
        def 					UpperCAmelCase		(       self				)       ->   int:
            UpperCamelCase :int										=     self.get_auto_remove_tmp_dir()
            UpperCamelCase :List[str]										=     F'''
              --model_name Helsinki-NLP/opus-mt-en-ro
              --save_dir {output_dir}
              --data_dir {self.test_file_dir_str}/test_data/wmt_en_ro
              --num_beams 2
              --task translation
          '''.split()
  
            # we want this test to run even if there is only one GPU, but if there are more we use them all
            UpperCamelCase :List[str]										=     get_gpu_count()
            UpperCamelCase :Optional[Any]										=     F'''
              -m torch.distributed.launch
              --nproc_per_node={n_gpu}
              {self.test_file_dir}/run_distributed_eval.py
          '''.split()
            UpperCamelCase :List[Any]										=     [sys.executable] + distributed_args + args
            execute_subprocess_async(SCREAMING_SNAKE_CASE_					,       env=self.get_env()				)
  
            UpperCamelCase :Tuple										=     os.path.join(SCREAMING_SNAKE_CASE_					,       '''test_bleu.json'''				)
            UpperCamelCase :str										=     load_json(SCREAMING_SNAKE_CASE_				)
            # print(metrics)
            self.assertGreaterEqual(metrics['''bleu''']					,       25				)
  
  
  
  
  
  