





'''simple docstring'''







from __future__ import annotations

import unittest

from transformers import RoFormerConfig, 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 (
       TFRoFormerForCausalLM,
       TFRoFormerForMaskedLM,
       TFRoFormerForMultipleChoice,
       TFRoFormerForQuestionAnswering,
       TFRoFormerForSequenceClassification,
       TFRoFormerForTokenClassification,
       TFRoFormerModel,
   )
   from transformers.models.roformer.modeling_tf_roformer import (
       TFRoFormerSelfAttention,
       TFRoFormerSinusoidalPositionalEmbedding,
   )
class 			_lowercase						:







     def __init__( self    ,   A__    ,   A__=13    ,   A__=7    ,   A__=True    ,   A__=True    ,   A__=True    ,   A__=True    ,   A__=99    ,   A__=32    ,   A__=2    ,   A__=4    ,   A__=37    ,   A__="gelu"    ,   A__=0.1    ,   A__=0.1    ,   A__=5_12    ,   A__=16    ,   A__=2    ,   A__=0.0_2    ,   A__=3    ,   A__=4    ,   A__=None    ,   ) ->	int:
      snake_case				=			parent
      snake_case				=			13
      snake_case				=			7
      snake_case				=			True
      snake_case				=			True
      snake_case				=			True
      snake_case				=			True
      snake_case				=			99
      snake_case				=			32
      snake_case				=			2
      snake_case				=			4
      snake_case				=			37
      snake_case				=			'''gelu'''
      snake_case				=			0.1
      snake_case				=			0.1
      snake_case				=			5_12
      snake_case				=			16
      snake_case				=			2
      snake_case				=			0.0_2
      snake_case				=			3
      snake_case				=			4
      snake_case				=			None







     def     UpperCamelCase			( self    ) ->	Dict:
      snake_case				=			ids_tensor([self.batch_size, self.seq_length]    ,   self.vocab_size    )

      snake_case				=			None
      if self.use_input_mask:
       snake_case				=			random_attention_mask([self.batch_size, self.seq_length]    )

      snake_case				=			None
      if self.use_token_type_ids:
       snake_case				=			ids_tensor([self.batch_size, self.seq_length]    ,   self.type_vocab_size    )

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

      snake_case				=			RoFormerConfig(
          vocab_size=self.vocab_size    ,   hidden_size=self.hidden_size    ,   num_hidden_layers=self.num_hidden_layers    ,   num_attention_heads=self.num_attention_heads    ,   intermediate_size=self.intermediate_size    ,   hidden_act=self.hidden_act    ,   hidden_dropout_prob=self.hidden_dropout_prob    ,   attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,   max_position_embeddings=self.max_position_embeddings    ,   type_vocab_size=self.type_vocab_size    ,   initializer_range=self.initializer_range    ,   return_dict=A__    ,   )

      return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels







     def     UpperCamelCase			( self    ,   A__    ,   A__    ,   A__    ,   A__    ,   A__    ,   A__    ,   A__    ) ->	Union[str, Any]:
      snake_case				=			TFRoFormerModel(config=A__    )
      snake_case				=			{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}

      snake_case				=			[input_ids, input_mask]
      snake_case				=			model(A__    )

      snake_case				=			model(A__    )

      self.parent.assertEqual(result.last_hidden_state.shape    ,   (self.batch_size, self.seq_length, self.hidden_size)    )







     def     UpperCamelCase			( self    ,   A__    ,   A__    ,   A__    ,   A__    ,   A__    ,   A__    ,   A__    ) ->	Optional[int]:
      snake_case				=			True
      snake_case				=			TFRoFormerForCausalLM(config=A__    )
      snake_case				=			{
          '''input_ids''': input_ids,
          '''attention_mask''': input_mask,
          '''token_type_ids''': token_type_ids,
      }
      snake_case				=			model(A__    )['''logits''']
      self.parent.assertListEqual(
          list(prediction_scores.numpy().shape    )    ,   [self.batch_size, self.seq_length, self.vocab_size]    )







     def     UpperCamelCase			( self    ,   A__    ,   A__    ,   A__    ,   A__    ,   A__    ,   A__    ,   A__    ) ->	Union[str, Any]:
      snake_case				=			TFRoFormerForMaskedLM(config=A__    )
      snake_case				=			{
          '''input_ids''': input_ids,
          '''attention_mask''': input_mask,
          '''token_type_ids''': token_type_ids,
      }
      snake_case				=			model(A__    )
      self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, self.seq_length, self.vocab_size)    )







     def     UpperCamelCase			( self    ,   A__    ,   A__    ,   A__    ,   A__    ,   A__    ,   A__    ,   A__    ) ->	Dict:
      snake_case				=			self.num_labels
      snake_case				=			TFRoFormerForSequenceClassification(config=A__    )
      snake_case				=			{
          '''input_ids''': input_ids,
          '''attention_mask''': input_mask,
          '''token_type_ids''': token_type_ids,
      }

      snake_case				=			model(A__    )
      self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, self.num_labels)    )







     def     UpperCamelCase			( self    ,   A__    ,   A__    ,   A__    ,   A__    ,   A__    ,   A__    ,   A__    ) ->	List[str]:
      snake_case				=			self.num_choices
      snake_case				=			TFRoFormerForMultipleChoice(config=A__    )
      snake_case				=			tf.tile(tf.expand_dims(A__    ,   1    )    ,   (1, self.num_choices, 1)    )
      snake_case				=			tf.tile(tf.expand_dims(A__    ,   1    )    ,   (1, self.num_choices, 1)    )
      snake_case				=			tf.tile(tf.expand_dims(A__    ,   1    )    ,   (1, self.num_choices, 1)    )
      snake_case				=			{
          '''input_ids''': multiple_choice_inputs_ids,
          '''attention_mask''': multiple_choice_input_mask,
          '''token_type_ids''': multiple_choice_token_type_ids,
      }
      snake_case				=			model(A__    )
      self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, self.num_choices)    )







     def     UpperCamelCase			( self    ,   A__    ,   A__    ,   A__    ,   A__    ,   A__    ,   A__    ,   A__    ) ->	Dict:
      snake_case				=			self.num_labels
      snake_case				=			TFRoFormerForTokenClassification(config=A__    )
      snake_case				=			{
          '''input_ids''': input_ids,
          '''attention_mask''': input_mask,
          '''token_type_ids''': token_type_ids,
      }
      snake_case				=			model(A__    )
      self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, self.seq_length, self.num_labels)    )







     def     UpperCamelCase			( self    ,   A__    ,   A__    ,   A__    ,   A__    ,   A__    ,   A__    ,   A__    ) ->	Dict:
      snake_case				=			TFRoFormerForQuestionAnswering(config=A__    )
      snake_case				=			{
          '''input_ids''': input_ids,
          '''attention_mask''': input_mask,
          '''token_type_ids''': token_type_ids,
      }

      snake_case				=			model(A__    )
      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    ) ->	str:
      snake_case				=			self.prepare_config_and_inputs()
      (
          (
          snake_case
      )				,		(
          snake_case
      )				,		(
          snake_case
      )				,		(
          snake_case
      )				,		(
          snake_case
      )				,		(
          snake_case
      )				,		(
          snake_case
      )				,		
      )				=			config_and_inputs
      snake_case				=			{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
      return config, inputs_dict




@require_tf
class 			_lowercase						(       __a				,		__a				,		unittest.TestCase					):
     _UpperCAmelCase										=					(
         (
             TFRoFormerModel,
             TFRoFormerForCausalLM,
             TFRoFormerForMaskedLM,
             TFRoFormerForQuestionAnswering,
             TFRoFormerForSequenceClassification,
             TFRoFormerForTokenClassification,
             TFRoFormerForMultipleChoice,
         )
         if is_tf_available()
         else ()
     )
     _UpperCAmelCase										=					(
         {
             '''feature-extraction''': TFRoFormerModel,
             '''fill-mask''': TFRoFormerForMaskedLM,
             '''question-answering''': TFRoFormerForQuestionAnswering,
             '''text-classification''': TFRoFormerForSequenceClassification,
             '''text-generation''': TFRoFormerForCausalLM,
             '''token-classification''': TFRoFormerForTokenClassification,
             '''zero-shot''': TFRoFormerForSequenceClassification,
         }
         if is_tf_available()
         else {}
     )

     _UpperCAmelCase										=					False
     _UpperCAmelCase										=					False







     def     UpperCamelCase			( self    ,   A__    ,   A__    ,   A__    ,   A__    ,   A__    ) ->	Union[str, Any]:
      if pipeline_test_casse_name == "TextGenerationPipelineTests":
       return True

      return False







     def     UpperCamelCase			( self    ) ->	Any:
      snake_case				=			TFRoFormerModelTester(self    )
      snake_case				=			ConfigTester(self    ,   config_class=A__    ,   hidden_size=37    )







     def     UpperCamelCase			( self    ) ->	str:
      self.config_tester.run_common_tests()







     def     UpperCamelCase			( self    ) ->	Any:
      snake_case				=			self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*A__    )







     def     UpperCamelCase			( self    ) ->	List[str]:
      snake_case				=			self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_lm(*A__    )







     def     UpperCamelCase			( self    ) ->	int:
      snake_case				=			self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_lm_head(*A__    )







     def     UpperCamelCase			( self    ) ->	Tuple:
      snake_case				=			self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_multiple_choice(*A__    )







     def     UpperCamelCase			( self    ) ->	Tuple:
      snake_case				=			self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_question_answering(*A__    )







     def     UpperCamelCase			( self    ) ->	Dict:
      snake_case				=			self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_sequence_classification(*A__    )







     def     UpperCamelCase			( self    ) ->	List[Any]:
      snake_case				=			self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_token_classification(*A__    )







     @slow
     def     UpperCamelCase			( self    ) ->	Union[str, Any]:
      snake_case				=			TFRoFormerModel.from_pretrained('''junnyu/roformer_chinese_base'''    )
      self.assertIsNotNone(A__    )




@require_tf
class 			_lowercase						(       unittest.TestCase					):







     @slow
     def     UpperCamelCase			( self    ) ->	int:
      snake_case				=			TFRoFormerForMaskedLM.from_pretrained('''junnyu/roformer_chinese_base'''    )
      snake_case				=			tf.constant([[0, 1, 2, 3, 4, 5]]    )
      snake_case				=			model(A__    )[0]

      # TODO Replace vocab size
      snake_case				=			5_00_00

      snake_case				=			[1, 6, vocab_size]
      self.assertEqual(output.shape    ,   A__    )

      print(output[:, :3, :3]    )

      # TODO Replace values below with what was printed above.
      snake_case				=			tf.constant(
          [
              [
                  [-0.1_2_0_5_3_3_4_1, -1.0_2_6_4_9_0_1, 0.2_9_2_2_1_9_4_6],
                  [-1.5_1_3_3_7_8_3, 0.1_9_7_4_3_3, 0.1_5_1_9_0_6_0_7],
                  [-5.0_1_3_5_4_0_3, -3.9_0_0_2_5_6, -0.8_4_0_3_8_7_6_4],
              ]
          ]    )
      tf.debugging.assert_near(output[:, :3, :3]    ,   A__    ,   atol=1e-4    )




@require_tf
class 			_lowercase						(       unittest.TestCase					):
     _UpperCAmelCase										=					1E-4







     def     UpperCamelCase			( self    ) ->	List[str]:
      snake_case				=			tf.constant([[4, 10]]    )
      snake_case				=			TFRoFormerSinusoidalPositionalEmbedding(num_positions=6    ,   embedding_dim=6    )

      snake_case				=			emba(input_ids.shape    )
      snake_case				=			tf.constant(
          [[0.0_0_0_0, 0.0_0_0_0, 0.0_0_0_0, 1.0_0_0_0, 1.0_0_0_0, 1.0_0_0_0], [0.8_4_1_5, 0.0_4_6_4, 0.0_0_2_2, 0.5_4_0_3, 0.9_9_8_9, 1.0_0_0_0]]    )

      tf.debugging.assert_near(A__    ,   A__    ,   atol=self.tolerance    )







     def     UpperCamelCase			( self    ) ->	Union[str, Any]:
      snake_case				=			tf.constant(
          [
              [0.0_0_0_0, 0.0_0_0_0, 0.0_0_0_0, 0.0_0_0_0, 0.0_0_0_0],
              [0.8_4_1_5, 0.8_2_1_9, 0.8_0_2_0, 0.7_8_1_9, 0.7_6_1_7],
              [0.9_0_9_3, 0.9_3_6_4, 0.9_5_8_1, 0.9_7_4_9, 0.9_8_7_0],
          ]    )
      snake_case				=			TFRoFormerSinusoidalPositionalEmbedding(num_positions=5_12    ,   embedding_dim=5_12    )
      emba([2, 16, 5_12]    )
      snake_case				=			emba.weight[:3, :5]

      tf.debugging.assert_near(A__    ,   A__    ,   atol=self.tolerance    )




@require_tf
class 			_lowercase						(       unittest.TestCase					):
     _UpperCAmelCase										=					1E-4







     def     UpperCamelCase			( self    ) ->	List[Any]:
      # 2,12,16,64
      snake_case				=			tf.reshape(tf.range(2 * 12 * 16 * 64    ,   dtype=tf.floataa    )    ,   shape=(2, 12, 16, 64)    ) / 1_00

      snake_case				=			-tf.reshape(tf.range(2 * 12 * 16 * 64    ,   dtype=tf.floataa    )    ,   shape=(2, 12, 16, 64)    ) / 1_00

      snake_case				=			TFRoFormerSinusoidalPositionalEmbedding(num_positions=32    ,   embedding_dim=64    )
      snake_case				=			embed_positions([2, 16, 7_68]    )[None, None, :, :]

      snake_case				,		snake_case				=			TFRoFormerSelfAttention.apply_rotary_position_embeddings(
          A__    ,   A__    ,   A__    )

      snake_case				=			tf.constant(
          [
              [0.0_0_0_0, 0.0_1_0_0, 0.0_2_0_0, 0.0_3_0_0, 0.0_4_0_0, 0.0_5_0_0, 0.0_6_0_0, 0.0_7_0_0],
              [-0.2_0_1_2, 0.8_8_9_7, 0.0_2_6_3, 0.9_4_0_1, 0.2_0_7_4, 0.9_4_6_3, 0.3_4_8_1, 0.9_3_4_3],
              [-1.7_0_5_7, 0.6_2_7_1, -1.2_1_4_5, 1.3_8_9_7, -0.6_3_0_3, 1.7_6_4_7, -0.1_1_7_3, 1.8_9_8_5],
              [-2.1_7_3_1, -1.6_3_9_7, -2.7_3_5_8, 0.2_8_5_4, -2.1_8_4_0, 1.7_1_8_3, -1.3_0_1_8, 2.4_8_7_1],
              [0.2_7_1_7, -3.6_1_7_3, -2.9_2_0_6, -2.1_9_8_8, -3.6_6_3_8, 0.3_8_5_8, -2.9_1_5_5, 2.2_9_8_0],
              [3.9_8_5_9, -2.1_5_8_0, -0.7_9_8_4, -4.4_9_0_4, -4.1_1_8_1, -2.0_2_5_2, -4.4_7_8_2, 1.1_2_5_3],
          ]    )
      snake_case				=			tf.constant(
          [
              [0.0_0_0_0, -0.0_1_0_0, -0.0_2_0_0, -0.0_3_0_0, -0.0_4_0_0, -0.0_5_0_0, -0.0_6_0_0, -0.0_7_0_0],
              [0.2_0_1_2, -0.8_8_9_7, -0.0_2_6_3, -0.9_4_0_1, -0.2_0_7_4, -0.9_4_6_3, -0.3_4_8_1, -0.9_3_4_3],
              [1.7_0_5_7, -0.6_2_7_1, 1.2_1_4_5, -1.3_8_9_7, 0.6_3_0_3, -1.7_6_4_7, 0.1_1_7_3, -1.8_9_8_5],
              [2.1_7_3_1, 1.6_3_9_7, 2.7_3_5_8, -0.2_8_5_4, 2.1_8_4_0, -1.7_1_8_3, 1.3_0_1_8, -2.4_8_7_1],
              [-0.2_7_1_7, 3.6_1_7_3, 2.9_2_0_6, 2.1_9_8_8, 3.6_6_3_8, -0.3_8_5_8, 2.9_1_5_5, -2.2_9_8_0],
              [-3.9_8_5_9, 2.1_5_8_0, 0.7_9_8_4, 4.4_9_0_4, 4.1_1_8_1, 2.0_2_5_2, 4.4_7_8_2, -1.1_2_5_3],
          ]    )

      tf.debugging.assert_near(query_layer[0, 0, :6, :8]    ,   A__    ,   atol=self.tolerance    )
      tf.debugging.assert_near(key_layer[0, 0, :6, :8]    ,   A__    ,   atol=self.tolerance    )








'''simple docstring'''







from ...processing_utils import ProcessorMixin
class 			_lowercase						(       __a					):
     _UpperCAmelCase										=					'''WhisperFeatureExtractor'''
     _UpperCAmelCase										=					'''WhisperTokenizer'''







     def __init__( self    ,   A__    ,   A__    ) ->	Optional[Any]:
      super().__init__(A__    ,   A__    )
      snake_case				=			self.feature_extractor
      snake_case				=			False







     def     UpperCamelCase			( self    ,   A__=None    ,   A__=None    ,   A__=True    ) ->	Union[str, Any]:
      return self.tokenizer.get_decoder_prompt_ids(task=A__    ,   language=A__    ,   no_timestamps=A__    )







     def __call__( self    ,   *A__    ,   **A__    ) ->	Dict:
      # For backward compatibility
      if self._in_target_context_manager:
       return self.current_processor(*A__    ,   **A__    )

      snake_case				=			kwargs.pop('''audio'''    ,   A__    )
      snake_case				=			kwargs.pop('''sampling_rate'''    ,   A__    )
      snake_case				=			kwargs.pop('''text'''    ,   A__    )
      if len(A__    ) > 0:
       snake_case				=			args[0]
       snake_case				=			args[1:]

      if audio is None and text is None:
       raise ValueError('''You need to specify either an `audio` or `text` input to process.'''    )

      if audio is not None:
       snake_case				=			self.feature_extractor(A__    ,   *A__    ,   sampling_rate=A__    ,   **A__    )
      if text is not None:
       snake_case				=			self.tokenizer(A__    ,   **A__    )

      if text is None:
       return inputs

      elif audio is None:
       return encodings
      else:
       snake_case				=			encodings['''input_ids''']
       return inputs







     def     UpperCamelCase			( self    ,   *A__    ,   **A__    ) ->	Optional[Any]:
      return self.tokenizer.batch_decode(*A__    ,   **A__    )







     def     UpperCamelCase			( self    ,   *A__    ,   **A__    ) ->	str:
      return self.tokenizer.decode(*A__    ,   **A__    )







     def     UpperCamelCase			( self    ,   A__    ,   A__="np"    ) ->	Optional[Any]:
      return self.tokenizer.get_prompt_ids(A__    ,   return_tensors=A__    )

