'''simple docstring'''


import argparse
import os
import pathlib

import fairseq
import torch
from fairseq.modules import TransformerSentenceEncoderLayer
from packaging import version

from transformers import (
    DataaVecTextConfig,
    DataaVecTextForMaskedLM,
    DataaVecTextForSequenceClassification,
    DataaVecTextModel,
)
from transformers.models.bert.modeling_bert import (
    BertIntermediate,
    BertLayer,
    BertOutput,
    BertSelfAttention,
    BertSelfOutput,
)

# IMPORTANT: In order for this script to run, please make sure to download the dictionary: `dict.txt` from wget https://dl.fbaipublicfiles.com/fairseq/models/roberta.large.tar.gz
# File copied from https://github.com/pytorch/fairseq/blob/main/examples/data2vec/models/data2vec_text.py
from transformers.utils import logging


if version.parse(fairseq.__version__) < version.parse('''0.9.0'''):
 raise Exception('''requires fairseq >= 0.9.0''')


logging.set_verbosity_info()
snake_case__     :			Any      			=  logging.get_logger(__name__)

snake_case__     :			Optional[int]      			=  '''Hello world! cécé herlolip'''


def 					_lowerCamelCase    (      lowerCamelCase_					:							str	,     lowerCamelCase_					:							str	,     lowerCamelCase_					:							bool   ):



     """simple docstring"""





     UpperCAmelCase_   ,			UpperCAmelCase_							:   Union[str, Any]   =      os.path.split(lowerCamelCase_   )
     UpperCAmelCase_							:   Dict   =      DataaVecTextModel.from_pretrained(
         lowerCamelCase_	,     checkpoint_file=lowerCamelCase_   )
     dataavec.eval()  # disable dropout
     UpperCAmelCase_							:   Union[str, Any]   =      dataavec.models[0]
     UpperCAmelCase_							:   Optional[int]   =      dataavec_model.encoder.sentence_encoder
     UpperCAmelCase_							:   Tuple   =      DataaVecTextConfig(
         vocab_size=dataavec_sent_encoder.embed_tokens.num_embeddings	,     hidden_size=dataavec_model.args.encoder_embed_dim	,     num_hidden_layers=dataavec_model.args.encoder_layers	,     num_attention_heads=dataavec_model.args.encoder_attention_heads	,     intermediate_size=dataavec_model.args.encoder_ffn_embed_dim	,     max_position_embeddings=514	,     type_vocab_size=1	,     layer_norm_eps=1e-5	,     )
     if classification_head:
          UpperCAmelCase_							:   Tuple   =      dataavec.model.classification_heads['mnli'].out_proj.weight.shape[0]
     print('Our BERT config:'	,     lowerCamelCase_   )

     UpperCAmelCase_							:   Optional[Any]   =      DataaVecTextForSequenceClassification(lowerCamelCase_   ) if classification_head else DataaVecTextForMaskedLM(lowerCamelCase_   )
     model.eval()

     # Now let's copy all the weights.
     # Embeddings
     UpperCAmelCase_							:   List[Any]   =      dataavec_sent_encoder.embed_tokens.weight
     UpperCAmelCase_							:   List[str]   =      dataavec_sent_encoder.embed_positions.weight
     UpperCAmelCase_							:   Dict   =      torch.zeros_like(
         model.dataavec_text.embeddings.token_type_embeddings.weight   )  # just zero them out b/c data2vec doesn't use them.
     UpperCAmelCase_							:   Union[str, Any]   =      dataavec_sent_encoder.layernorm_embedding.weight
     UpperCAmelCase_							:   Any   =      dataavec_sent_encoder.layernorm_embedding.bias

     for i in range(config.num_hidden_layers   ):
          # Encoder: start of layer
          UpperCAmelCase_							:   BertLayer   =      model.dataavec_text.encoder.layer[i]
          UpperCAmelCase_							:   TransformerSentenceEncoderLayer   =      dataavec_sent_encoder.layers[i]

          # self attention
          UpperCAmelCase_							:   BertSelfAttention   =      layer.attention.self
          assert dataavec_layer.self_attn.k_proj.weight.data.shape == torch.Size(
              (config.hidden_size, config.hidden_size)   ), (
              "Shape for data2vec_layer.self_attn.k_proj.weight.data should be"
              F''' {torch.Size((config.hidden_size, config.hidden_size)   )}'''
          )
          assert dataavec_layer.self_attn.q_proj.weight.data.shape == torch.Size(
              (config.hidden_size, config.hidden_size)   ), (
              "Shape for data2vec_layer.self_attn.q_proj.weight.data should be"
              F''' {torch.Size((config.hidden_size, config.hidden_size)   )}'''
          )
          assert dataavec_layer.self_attn.v_proj.weight.data.shape == torch.Size(
              (config.hidden_size, config.hidden_size)   ), (
              "Shape for data2vec_layer.self_attn.v_proj.weight.data should be"
              F''' {torch.Size((config.hidden_size, config.hidden_size)   )}'''
          )

          UpperCAmelCase_							:   int   =      dataavec_layer.self_attn.q_proj.weight
          UpperCAmelCase_							:   Any   =      dataavec_layer.self_attn.q_proj.bias
          UpperCAmelCase_							:   Optional[Any]   =      dataavec_layer.self_attn.k_proj.weight
          UpperCAmelCase_							:   List[Any]   =      dataavec_layer.self_attn.k_proj.bias
          UpperCAmelCase_							:   Tuple   =      dataavec_layer.self_attn.v_proj.weight
          UpperCAmelCase_							:   Optional[Any]   =      dataavec_layer.self_attn.v_proj.bias

          # self-attention output
          UpperCAmelCase_							:   BertSelfOutput   =      layer.attention.output
          assert (
              self_output.dense.weight.shape == dataavec_layer.self_attn.out_proj.weight.shape
          ), F'''Shape for self_output.dense.weight should be {dataavec_layer.self_attn.out_proj.weight.shape}'''
          UpperCAmelCase_							:   str   =      dataavec_layer.self_attn.out_proj.weight
          UpperCAmelCase_							:   Tuple   =      dataavec_layer.self_attn.out_proj.bias
          UpperCAmelCase_							:   Union[str, Any]   =      dataavec_layer.self_attn_layer_norm.weight
          UpperCAmelCase_							:   Union[str, Any]   =      dataavec_layer.self_attn_layer_norm.bias

          # intermediate
          UpperCAmelCase_							:   BertIntermediate   =      layer.intermediate
          assert (
              intermediate.dense.weight.shape == dataavec_layer.fca.weight.shape
          ), F'''Shape for intermediate.dense.weight should be {dataavec_layer.fca.weight.shape}'''
          UpperCAmelCase_							:   List[str]   =      dataavec_layer.fca.weight
          UpperCAmelCase_							:   Any   =      dataavec_layer.fca.bias

          # output
          UpperCAmelCase_							:   BertOutput   =      layer.output
          assert (
              bert_output.dense.weight.shape == dataavec_layer.fca.weight.shape
          ), F'''Shape for bert_output.dense.weight should be {dataavec_layer.fca.weight.shape}'''
          UpperCAmelCase_							:   Union[str, Any]   =      dataavec_layer.fca.weight
          UpperCAmelCase_							:   int   =      dataavec_layer.fca.bias
          UpperCAmelCase_							:   Optional[Any]   =      dataavec_layer.final_layer_norm.weight
          UpperCAmelCase_							:   List[str]   =      dataavec_layer.final_layer_norm.bias
          # end of layer

     if classification_head:
          UpperCAmelCase_							:   Dict   =      dataavec.model.classification_heads['mnli'].dense.weight
          UpperCAmelCase_							:   Optional[int]   =      dataavec.model.classification_heads['mnli'].dense.bias
          UpperCAmelCase_							:   Optional[int]   =      dataavec.model.classification_heads['mnli'].out_proj.weight
          UpperCAmelCase_							:   int   =      dataavec.model.classification_heads['mnli'].out_proj.bias
     else:
          # LM Head
          UpperCAmelCase_							:   Tuple   =      dataavec_model.encoder.lm_head.dense.weight
          UpperCAmelCase_							:   Dict   =      dataavec_model.encoder.lm_head.dense.bias
          UpperCAmelCase_							:   Optional[Any]   =      dataavec_model.encoder.lm_head.layer_norm.weight
          UpperCAmelCase_							:   Optional[int]   =      dataavec_model.encoder.lm_head.layer_norm.bias
          UpperCAmelCase_							:   List[Any]   =      dataavec_model.encoder.lm_head.weight
          UpperCAmelCase_							:   List[Any]   =      dataavec_model.encoder.lm_head.bias

     # Let's check that we get the same results.
     UpperCAmelCase_							:   torch.Tensor   =      dataavec.encode(lowerCamelCase_   ).unsqueeze(0   )  # batch of size 1

     UpperCAmelCase_							:   Tuple   =      model(lowerCamelCase_   )[0]
     if classification_head:
          UpperCAmelCase_							:   Optional[int]   =      dataavec.model.classification_heads['mnli'](dataavec.extract_features(lowerCamelCase_   )   )
     else:
          UpperCAmelCase_							:   str   =      dataavec_model(lowerCamelCase_   )[0]
     print(our_output.shape	,     their_output.shape   )
     UpperCAmelCase_							:   Optional[int]   =      torch.max(torch.abs(our_output - their_output   )   ).item()
     print(F'''max_absolute_diff = {max_absolute_diff}'''   )  # ~ 1e-7
     UpperCAmelCase_							:   List[Any]   =      torch.allclose(lowerCamelCase_	,     lowerCamelCase_	,     atol=1e-3   )
     print('Do both models output the same tensors?'	,     '🔥' if success else '💩'   )
     if not success:
          raise Exception('Something went wRoNg'   )

     pathlib.Path(lowerCamelCase_   ).mkdir(parents=lowerCamelCase_	,     exist_ok=lowerCamelCase_   )
     print(F'''Saving model to {pytorch_dump_folder_path}'''   )
     model.save_pretrained(lowerCamelCase_   )


if __name__ == "__main__":
 snake_case__     :			int      			=  argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     '''--checkpoint_path''', default=None, type=str, required=True, help='''Path the official PyTorch dump.'''
 )
 parser.add_argument(
     '''--pytorch_dump_folder_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
 )
 parser.add_argument(
     '''--classification_head''', action='''store_true''', help='''Whether to convert a final classification head.'''
 )
 snake_case__     :			List[Any]      			=  parser.parse_args()
 convert_dataavec_checkpoint_to_pytorch(
     args.checkpoint_path, args.pytorch_dump_folder_path, args.classification_head
 )







'''simple docstring'''


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      __SCREAMING_SNAKE_CASE						:







  '''simple docstring'''






  def __init__( self      ,		snake_case_      ,		):




       '''simple docstring'''

       UpperCAmelCase_							:   str   =      parent
       UpperCAmelCase_							:   Tuple   =      1_3
       UpperCAmelCase_							:   Dict   =      7
       UpperCAmelCase_							:   Union[str, Any]   =      True
       UpperCAmelCase_							:   Optional[Any]   =      True
       UpperCAmelCase_							:   Tuple   =      True
       UpperCAmelCase_							:   Dict   =      True
       UpperCAmelCase_							:   List[Any]   =      True
       UpperCAmelCase_							:   Union[str, Any]   =      False
       UpperCAmelCase_							:   Any   =      False
       UpperCAmelCase_							:   List[str]   =      False
       UpperCAmelCase_							:   int   =      2
       UpperCAmelCase_							:   Union[str, Any]   =      9_9
       UpperCAmelCase_							:   Dict   =      0
       UpperCAmelCase_							:   List[str]   =      3_2
       UpperCAmelCase_							:   str   =      2
       UpperCAmelCase_							:   int   =      4
       UpperCAmelCase_							:   Dict   =      0.1
       UpperCAmelCase_							:   int   =      0.1
       UpperCAmelCase_							:   List[str]   =      5_1_2
       UpperCAmelCase_							:   Union[str, Any]   =      1_6
       UpperCAmelCase_							:   List[Any]   =      2
       UpperCAmelCase_							:   int   =      0.02
       UpperCAmelCase_							:   Union[str, Any]   =      3
       UpperCAmelCase_							:   Union[str, Any]   =      4
       UpperCAmelCase_							:   Optional[int]   =      'last'
       UpperCAmelCase_							:   List[Any]   =      True
       UpperCAmelCase_							:   Union[str, Any]   =      None
       UpperCAmelCase_							:   int   =      0


  def _UpperCamelCase     ( self						):




       '''simple docstring'''

       UpperCAmelCase_							:   Tuple   =      ids_tensor([self.batch_size, self.seq_length]      ,		self.vocab_size						)
       UpperCAmelCase_							:   Tuple   =      random_attention_mask([self.batch_size, self.seq_length]      ,		dtype=tf.floataa						)

       UpperCAmelCase_							:   Optional[Any]   =      None
       if self.use_input_lengths:
            UpperCAmelCase_							:   Any   =      (
                ids_tensor([self.batch_size]      ,		vocab_size=2						) + self.seq_length - 2
            )  # small variation of seq_length

       UpperCAmelCase_							:   Optional[Any]   =      None
       if self.use_token_type_ids:
            UpperCAmelCase_							:   Tuple   =      ids_tensor([self.batch_size, self.seq_length]      ,		self.n_langs						)

       UpperCAmelCase_							:   Any   =      None
       UpperCAmelCase_							:   Union[str, Any]   =      None
       UpperCAmelCase_							:   Optional[int]   =      None
       if self.use_labels:
            UpperCAmelCase_							:   Union[str, Any]   =      ids_tensor([self.batch_size]      ,		self.type_sequence_label_size						)
            UpperCAmelCase_							:   Any   =      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_							:   Any   =      ids_tensor([self.batch_size]      ,		self.num_choices						)

       UpperCAmelCase_							:   int   =      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      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		):




       '''simple docstring'''

       UpperCAmelCase_							:   Tuple   =      TFXLMModel(config=snake_case_						)
       UpperCAmelCase_							:   int   =      {'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
       UpperCAmelCase_							:   Tuple   =      model(snake_case_						)

       UpperCAmelCase_							:   Any   =      [input_ids, input_mask]
       UpperCAmelCase_							:   Optional[Any]   =      model(snake_case_						)
       self.parent.assertEqual(result.last_hidden_state.shape      ,		(self.batch_size, self.seq_length, self.hidden_size)						)


  def _UpperCamelCase     ( self      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		):




       '''simple docstring'''

       UpperCAmelCase_							:   List[str]   =      TFXLMWithLMHeadModel(snake_case_						)

       UpperCAmelCase_							:   Union[str, Any]   =      {'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
       UpperCAmelCase_							:   Optional[Any]   =      model(snake_case_						)

       UpperCAmelCase_							:   Tuple   =      outputs

       self.parent.assertEqual(result.logits.shape      ,		(self.batch_size, self.seq_length, self.vocab_size)						)


  def _UpperCamelCase     ( self      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		):




       '''simple docstring'''

       UpperCAmelCase_							:   List[str]   =      TFXLMForQuestionAnsweringSimple(snake_case_						)

       UpperCAmelCase_							:   Optional[int]   =      {'input_ids': input_ids, 'lengths': input_lengths}

       UpperCAmelCase_							:   Optional[int]   =      model(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      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		):




       '''simple docstring'''

       UpperCAmelCase_							:   List[str]   =      TFXLMForSequenceClassification(snake_case_						)

       UpperCAmelCase_							:   Dict   =      {'input_ids': input_ids, 'lengths': input_lengths}

       UpperCAmelCase_							:   Tuple   =      model(snake_case_						)

       self.parent.assertEqual(result.logits.shape      ,		(self.batch_size, self.type_sequence_label_size)						)


  def _UpperCamelCase     ( self      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		):




       '''simple docstring'''

       UpperCAmelCase_							:   int   =      self.num_labels
       UpperCAmelCase_							:   List[str]   =      TFXLMForTokenClassification(config=snake_case_						)
       UpperCAmelCase_							:   str   =      {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
       UpperCAmelCase_							:   Optional[int]   =      model(snake_case_						)
       self.parent.assertEqual(result.logits.shape      ,		(self.batch_size, self.seq_length, self.num_labels)						)


  def _UpperCamelCase     ( self      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		):




       '''simple docstring'''

       UpperCAmelCase_							:   List[Any]   =      self.num_choices
       UpperCAmelCase_							:   Optional[Any]   =      TFXLMForMultipleChoice(config=snake_case_						)
       UpperCAmelCase_							:   Tuple   =      tf.tile(tf.expand_dims(snake_case_      ,		1						)      ,		(1, self.num_choices, 1)						)
       UpperCAmelCase_							:   Dict   =      tf.tile(tf.expand_dims(snake_case_      ,		1						)      ,		(1, self.num_choices, 1)						)
       UpperCAmelCase_							:   str   =      tf.tile(tf.expand_dims(snake_case_      ,		1						)      ,		(1, self.num_choices, 1)						)
       UpperCAmelCase_							:   Tuple   =      {
           'input_ids': multiple_choice_inputs_ids,
           'attention_mask': multiple_choice_input_mask,
           'token_type_ids': multiple_choice_token_type_ids,
       }
       UpperCAmelCase_							:   int   =      model(snake_case_						)
       self.parent.assertEqual(result.logits.shape      ,		(self.batch_size, self.num_choices)						)






  def _UpperCamelCase     ( self						):




       '''simple docstring'''

       UpperCAmelCase_							:   Optional[int]   =      self.prepare_config_and_inputs()
       (
           (
           UpperCAmelCase_
       )   ,			(
           UpperCAmelCase_
       )   ,			(
           UpperCAmelCase_
       )   ,			(
           UpperCAmelCase_
       )   ,			(
           UpperCAmelCase_
       )   ,			(
           UpperCAmelCase_
       )   ,			(
           UpperCAmelCase_
       )   ,			(
           UpperCAmelCase_
       )   ,			(
           UpperCAmelCase_
       )   ,			
       )							:   Optional[int]   =      config_and_inputs
       UpperCAmelCase_							:   Any   =      {
           'input_ids': input_ids,
           'token_type_ids': token_type_ids,
           'langs': token_type_ids,
           'lengths': input_lengths,
       }
       return config, inputs_dict







@require_tf
class      __SCREAMING_SNAKE_CASE						(       lowerCamelCase_						,	lowerCamelCase_						,	unittest.TestCase       ):







  '''simple docstring'''






  lowerCamelCase_		:List[Any]						    =		(
      (
          TFXLMModel,
          TFXLMWithLMHeadModel,
          TFXLMForSequenceClassification,
          TFXLMForQuestionAnsweringSimple,
          TFXLMForTokenClassification,
          TFXLMForMultipleChoice,
      )
      if is_tf_available()
      else ()
  )
  lowerCamelCase_		:str						    =		(
      (TFXLMWithLMHeadModel,) if is_tf_available() else ()
  )  # TODO (PVP): Check other models whether language generation is also applicable
  lowerCamelCase_		:int						    =		(
      {
          '''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 {}
  )
  lowerCamelCase_		:List[Any]						    =		False
  lowerCamelCase_		:Dict						    =		False


  def _UpperCamelCase     ( self      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_      ,		snake_case_						):




       '''simple docstring'''

       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						):




       '''simple docstring'''

       UpperCAmelCase_							:   str   =      TFXLMModelTester(self						)
       UpperCAmelCase_							:   int   =      ConfigTester(self      ,		config_class=snake_case_      ,		emb_dim=3_7						)


  def _UpperCamelCase     ( self						):




       '''simple docstring'''

       self.config_tester.run_common_tests()


  def _UpperCamelCase     ( self						):




       '''simple docstring'''

       UpperCAmelCase_							:   Any   =      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_model(*snake_case_						)


  def _UpperCamelCase     ( self						):




       '''simple docstring'''

       UpperCAmelCase_							:   Optional[int]   =      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_lm_head(*snake_case_						)


  def _UpperCamelCase     ( self						):




       '''simple docstring'''

       UpperCAmelCase_							:   List[Any]   =      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_qa(*snake_case_						)


  def _UpperCamelCase     ( self						):




       '''simple docstring'''

       UpperCAmelCase_							:   Tuple   =      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_sequence_classif(*snake_case_						)


  def _UpperCamelCase     ( self						):




       '''simple docstring'''

       UpperCAmelCase_							:   Union[str, Any]   =      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_for_token_classification(*snake_case_						)


  def _UpperCamelCase     ( self						):




       '''simple docstring'''

       UpperCAmelCase_							:   Union[str, Any]   =      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_xlm_for_multiple_choice(*snake_case_						)






  @slow
  def _UpperCamelCase     ( self						):




       '''simple docstring'''

       for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            UpperCAmelCase_							:   int   =      TFXLMModel.from_pretrained(snake_case_						)
            self.assertIsNotNone(snake_case_						)







@require_tf
class      __SCREAMING_SNAKE_CASE						(       unittest.TestCase       ):







  '''simple docstring'''






  @slow
  def _UpperCamelCase     ( self						):




       '''simple docstring'''

       UpperCAmelCase_							:   Any   =      TFXLMWithLMHeadModel.from_pretrained('xlm-mlm-en-2048'						)
       UpperCAmelCase_							:   List[str]   =      tf.convert_to_tensor([[1_4, 4_4_7]]      ,		dtype=tf.intaa						)  # the president
       UpperCAmelCase_							:   Optional[int]   =      [
           1_4,
           4_4_7,
           1_4,
           4_4_7,
           1_4,
           4_4_7,
           1_4,
           4_4_7,
           1_4,
           4_4_7,
           1_4,
           4_4_7,
           1_4,
           4_4_7,
           1_4,
           4_4_7,
           1_4,
           4_4_7,
           1_4,
           4_4_7,
       ]  # 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_							:   Optional[int]   =      model.generate(snake_case_      ,		do_sample=snake_case_						)
       self.assertListEqual(output_ids[0].numpy().tolist()      ,		snake_case_						)






