
"""simple docstring"""




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       __magic_name__							:
       def __init__(  self			,					A_			,					)  ->						Tuple:





         """simple docstring"""




         _lowercase:      str   			=  parent
         _lowercase:      List[str]   			=  13
         _lowercase:      Any   			=  7
         _lowercase:      Tuple   			=  30
         _lowercase:      List[str]   			=  self.seq_length + self.mem_len
         _lowercase:      Optional[Any]   			=  15
         _lowercase:      List[Any]   			=  True
         _lowercase:      List[Any]   			=  True
         _lowercase:      Optional[int]   			=  99
         _lowercase:      int   			=  [10, 50, 80]
         _lowercase:      Optional[int]   			=  32
         _lowercase:      Optional[int]   			=  32
         _lowercase:      str   			=  4
         _lowercase:      str   			=  8
         _lowercase:      Optional[Any]   			=  128
         _lowercase:      Optional[Any]   			=  2
         _lowercase:      Tuple   			=  2
         _lowercase:      str   			=  None
         _lowercase:      Tuple   			=  1
         _lowercase:      Optional[int]   			=  0
         _lowercase:      Optional[Any]   			=  3
         _lowercase:      List[str]   			=  self.vocab_size - 1
         _lowercase:      str   			=  0.01
       def 				lowercase_				(  self							)  ->						Optional[Any]:





         """simple docstring"""




         _lowercase:      int   			=  ids_tensor([self.batch_size, self.seq_length]			,					self.vocab_size							)
         _lowercase:      int   			=  ids_tensor([self.batch_size, self.seq_length]			,					self.vocab_size							)

         _lowercase:      Any   			=  None
         if self.use_labels:
           _lowercase:      List[str]   			=  ids_tensor([self.batch_size, self.seq_length]			,					self.vocab_size							)

         _lowercase:      Any   			=  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 				lowercase_				(  self							)  ->						Optional[Any]:





         """simple docstring"""




         random.seed(self.seed							)
         tf.random.set_seed(self.seed							)
       def 				lowercase_				(  self			,					A_			,					A_			,					A_			,					A_							)  ->						Dict:





         """simple docstring"""




         _lowercase:      Optional[Any]   			=  TFTransfoXLModel(A_							)

         _lowercase			,					_lowercase:      Dict   			=  model(A_							).to_tuple()

         _lowercase:      str   			=  {'''input_ids''': input_ids_a, '''mems''': mems_a}

         _lowercase			,					_lowercase:      Any   			=  model(A_							).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 				lowercase_				(  self			,					A_			,					A_			,					A_			,					A_							)  ->						Union[str, Any]:





         """simple docstring"""




         _lowercase:      int   			=  TFTransfoXLLMHeadModel(A_							)

         _lowercase			,					_lowercase:      Optional[int]   			=  model(A_							).to_tuple()

         _lowercase:      Optional[Any]   			=  {'''input_ids''': input_ids_a, '''labels''': lm_labels}
         _lowercase			,					_lowercase:      int   			=  model(A_							).to_tuple()

         _lowercase			,					_lowercase:      Dict   			=  model([input_ids_a, mems_a]							).to_tuple()

         _lowercase:      Union[str, Any]   			=  {'''input_ids''': input_ids_a, '''mems''': mems_a, '''labels''': lm_labels}

         _lowercase			,					_lowercase:      Dict   			=  model(A_							).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 				lowercase_				(  self			,					A_			,					A_			,					A_			,					A_							)  ->						str:





         """simple docstring"""




         _lowercase:      List[Any]   			=  TFTransfoXLForSequenceClassification(A_							)
         _lowercase:      int   			=  model(A_							)
         self.parent.assertEqual(result.logits.shape			,					(self.batch_size, self.num_labels)							)



       def 				lowercase_				(  self							)  ->						Optional[int]:





         """simple docstring"""




         _lowercase:      Any   			=  self.prepare_config_and_inputs()
         ((_lowercase)			,					(_lowercase)			,					(_lowercase)			,					(_lowercase)):      Any   			=  config_and_inputs
         _lowercase:      Union[str, Any]   			=  {'''input_ids''': input_ids_a}
         return config, inputs_dict


@require_tf
class       __magic_name__							(							SCREAMING_SNAKE_CASE__ ,       SCREAMING_SNAKE_CASE__ ,       unittest.TestCase			):
       UpperCamelCase_ =		(
           (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
       )
       UpperCamelCase_ =		() if is_tf_available() else ()
       UpperCamelCase_ =		(
           {
               '''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
       UpperCamelCase_ =		False
       UpperCamelCase_ =		False
       UpperCamelCase_ =		False
       UpperCamelCase_ =		False
       def 				lowercase_				(  self			,					A_			,					A_			,					A_			,					A_			,					A_							)  ->						Union[str, Any]:





         """simple docstring"""




         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 				lowercase_				(  self							)  ->						Optional[Any]:





         """simple docstring"""




         _lowercase:      List[Any]   			=  TFTransfoXLModelTester(self							)
         _lowercase:      List[Any]   			=  ConfigTester(self			,					config_class=A_			,					d_embed=37							)
       def 				lowercase_				(  self							)  ->						str:





         """simple docstring"""




         self.config_tester.run_common_tests()
       def 				lowercase_				(  self							)  ->						Tuple:





         """simple docstring"""




         self.model_tester.set_seed()
         _lowercase:      List[Any]   			=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_model(*A_							)
       def 				lowercase_				(  self							)  ->						List[str]:





         """simple docstring"""




         self.model_tester.set_seed()
         _lowercase:      Tuple   			=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_lm_head(*A_							)
       def 				lowercase_				(  self							)  ->						Optional[int]:





         """simple docstring"""




         _lowercase:      List[Any]   			=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*A_							)
       def 				lowercase_				(  self							)  ->						int:





         """simple docstring"""




         _lowercase			,					_lowercase:      List[Any]   			=  self.model_tester.prepare_config_and_inputs_for_common()
         _lowercase:      List[str]   			=  [TFTransfoXLForSequenceClassification]

         for model_class in self.all_model_classes:
           _lowercase:      Union[str, Any]   			=  model_class(A_							)
           assert isinstance(model.get_input_embeddings()			,					tf.keras.layers.Layer							)
           if model_class in list_other_models_with_output_ebd:
             _lowercase:      Tuple   			=  model.get_output_embeddings()
             assert isinstance(A_			,					tf.keras.layers.Layer							)
             _lowercase:      List[str]   			=  model.get_bias()
             assert name is None
           else:
             _lowercase:      Optional[int]   			=  model.get_output_embeddings()
             assert x is None
             _lowercase:      List[str]   			=  model.get_bias()
             assert name is None
       def 				lowercase_				(  self							)  ->						List[str]:





         """simple docstring"""




         pass
       @slow
       def 				lowercase_				(  self							)  ->						List[str]:





         """simple docstring"""




         for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _lowercase:      Union[str, Any]   			=  TFTransfoXLModel.from_pretrained(A_							)
           self.assertIsNotNone(A_							)



       @unittest.skip(reason='''This model doesn\'t play well with fit() due to not returning a single loss.'''							)
       def 				lowercase_				(  self							)  ->						List[Any]:





         """simple docstring"""




         pass


@require_tf
class       __magic_name__							(							unittest.TestCase			):
       @unittest.skip('''Skip test until #12651 is resolved.'''							)
       @slow
       def 				lowercase_				(  self							)  ->						Any:





         """simple docstring"""




         _lowercase:      List[str]   			=  TFTransfoXLLMHeadModel.from_pretrained('''transfo-xl-wt103'''							)
         # fmt: off
         _lowercase:      Union[str, Any]   			=  tf.convert_to_tensor([[33,1297,2,1,1009,4,1109,1_1739,4762,358,5,25,245,22,1706,17,2_0098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,1,2604,4,1,329,3,6224,831,1_6002,2,8,603,7_8967,2_9546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,2_9546,54,8,3609,5,5_7211,49,4,1,277,18,8,1755,1_5691,3,341,25,416,693,4_2573,71,17,401,94,31,1_7919,2,2_9546,7873,18,1,435,23,1_1011,755,5,5167,3,7983,98,84,2,2_9546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,2_9546,824,1400,1868,2,19,160,2,311,8,5496,2,2_0920,17,25,1_5097,3,24,24,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
         _lowercase:      List[str]   			=  [33,1297,2,1,1009,4,1109,1_1739,4762,358,5,25,245,22,1706,17,2_0098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,1,2604,4,1,329,3,6224,831,1_6002,2,8,603,7_8967,2_9546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,2_9546,54,8,3609,5,5_7211,49,4,1,277,18,8,1755,1_5691,3,341,25,416,693,4_2573,71,17,401,94,31,1_7919,2,2_9546,7873,18,1,435,23,1_1011,755,5,5167,3,7983,98,84,2,2_9546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,2_9546,824,1400,1868,2,19,160,2,311,8,5496,2,2_0920,17,25,1_5097,3,24,24,0,33,1,1857,2,1,1009,4,1109,1_1739,4762,358,5,25,245,28,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,1,2604,4,1,329,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>

         _lowercase:      List[Any]   			=  model.generate(A_			,					max_length=200			,					do_sample=A_							)
         self.assertListEqual(output_ids[0].numpy().tolist()			,					A_							)


"""simple docstring"""




import argparse

from transformers import BigBirdConfig, BigBirdForPreTraining, BigBirdForQuestionAnswering, load_tf_weights_in_big_bird
from transformers.utils import logging


logging.set_verbosity_info()




def 			_lowerCAmelCase		(		_UpperCamelCase			,					_UpperCamelCase			,					_UpperCamelCase			,					_UpperCamelCase    ):






  """simple docstring"""



  _lowercase:      int   			=  BigBirdConfig.from_json_file(_UpperCamelCase    )
  print(f'''Building PyTorch model from configuration: {config}'''    )

  if is_trivia_qa:
    _lowercase:      Union[str, Any]   			=  BigBirdForQuestionAnswering(_UpperCamelCase    )
  else:
    _lowercase:      Dict   			=  BigBirdForPreTraining(_UpperCamelCase    )

  # Load weights from tf checkpoint
  load_tf_weights_in_big_bird(_UpperCamelCase			,					_UpperCamelCase			,					is_trivia_qa=_UpperCamelCase    )

  # Save pytorch-model
  print(f'''Save PyTorch model to {pytorch_dump_path}'''    )
  model.save_pretrained(_UpperCamelCase    )


if __name__ == "__main__":
  A__ :       List[Any]				= argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      '--tf_checkpoint_path', default=None, type=str, required=True, help='Path to the TensorFlow checkpoint path.'
  )
  parser.add_argument(
      '--big_bird_config_file',
      default=None,
      type=str,
      required=True,
      help=(
          'The config json file corresponding to the pre-trained BERT model. \n'
          'This specifies the model architecture.'
      ),
  )
  parser.add_argument(
      '--pytorch_dump_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
  )
  parser.add_argument(
      '--is_trivia_qa', action='store_true', help='Whether to convert a model with a trivia_qa head.'
  )
  A__ :       Optional[Any]				= parser.parse_args()
  convert_tf_checkpoint_to_pytorch(
      args.tf_checkpoint_path, args.big_bird_config_file, args.pytorch_dump_path, args.is_trivia_qa
  )
