

"""simple docstring"""



from __future__ import annotations

import os
import tempfile
import unittest

from transformers import ConvBertConfig, 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 (
     TFConvBertForMaskedLM,
     TFConvBertForMultipleChoice,
     TFConvBertForQuestionAnswering,
     TFConvBertForSequenceClassification,
     TFConvBertForTokenClassification,
     TFConvBertModel,
 )



class 					a						:



    """simple docstring"""



    def __init__(     self: int    ,						UpperCamelCase: Dict    ,						UpperCamelCase: Tuple=13    ,						UpperCamelCase: Tuple=7    ,						UpperCamelCase: Tuple=True    ,						UpperCamelCase: Optional[Any]=True    ,						UpperCamelCase: Dict=True    ,						UpperCamelCase: Tuple=True    ,						UpperCamelCase: List[str]=99    ,						UpperCamelCase: Optional[int]=32    ,						UpperCamelCase: Optional[Any]=2    ,						UpperCamelCase: List[str]=4    ,						UpperCamelCase: str=37    ,						UpperCamelCase: Optional[int]="gelu"    ,						UpperCamelCase: Dict=0.1    ,						UpperCamelCase: str=0.1    ,						UpperCamelCase: int=5_12    ,						UpperCamelCase: str=16    ,						UpperCamelCase: int=2    ,						UpperCamelCase: Any=0.02    ,						UpperCamelCase: List[str]=3    ,						UpperCamelCase: int=4    ,						UpperCamelCase: int=None    ,						):






         """simple docstring"""


         A__										=  parent
         A__										=  13
         A__										=  7
         A__										=  True
         A__										=  True
         A__										=  True
         A__										=  True
         A__										=  99
         A__										=  3_84
         A__										=  2
         A__										=  4
         A__										=  37
         A__										=  """gelu"""
         A__										=  0.1
         A__										=  0.1
         A__										=  5_12
         A__										=  16
         A__										=  2
         A__										=  0.02
         A__										=  3
         A__										=  4
         A__										=  1_28
         A__										=  2
         A__										=  9
         A__										=  1
         A__										=  None

    def 				UpperCamelCase	(     self: Optional[Any]       ):






         """simple docstring"""


         A__										=  ids_tensor([self.batch_size, self.seq_length]    ,						self.vocab_size       )

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

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

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

         A__										=  ConvBertConfig(
             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=UpperCamelCase    ,						)

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

    def 				UpperCamelCase	(     self: int    ,						UpperCamelCase: str    ,						UpperCamelCase: Optional[Any]    ,						UpperCamelCase: str    ,						UpperCamelCase: str    ,						UpperCamelCase: Tuple    ,						UpperCamelCase: str    ,						UpperCamelCase: Union[str, Any]       ):






         """simple docstring"""


         A__										=  TFConvBertModel(config=UpperCamelCase       )
         A__										=  {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}

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

         A__										=  model(UpperCamelCase       )

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

    def 				UpperCamelCase	(     self: Tuple    ,						UpperCamelCase: Tuple    ,						UpperCamelCase: List[Any]    ,						UpperCamelCase: Tuple    ,						UpperCamelCase: Union[str, Any]    ,						UpperCamelCase: Dict    ,						UpperCamelCase: List[str]    ,						UpperCamelCase: str       ):






         """simple docstring"""


         A__										=  TFConvBertForMaskedLM(config=UpperCamelCase       )
         A__										=  {
             """input_ids""": input_ids,
             """attention_mask""": input_mask,
             """token_type_ids""": token_type_ids,
         }
         A__										=  model(UpperCamelCase       )
         self.parent.assertEqual(result.logits.shape    ,						(self.batch_size, self.seq_length, self.vocab_size)       )

    def 				UpperCamelCase	(     self: Optional[int]    ,						UpperCamelCase: Union[str, Any]    ,						UpperCamelCase: Optional[int]    ,						UpperCamelCase: Union[str, Any]    ,						UpperCamelCase: Optional[int]    ,						UpperCamelCase: List[Any]    ,						UpperCamelCase: Dict    ,						UpperCamelCase: Dict       ):






         """simple docstring"""


         A__										=  self.num_labels
         A__										=  TFConvBertForSequenceClassification(config=UpperCamelCase       )
         A__										=  {
             """input_ids""": input_ids,
             """attention_mask""": input_mask,
             """token_type_ids""": token_type_ids,
         }

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

    def 				UpperCamelCase	(     self: List[Any]    ,						UpperCamelCase: Union[str, Any]    ,						UpperCamelCase: Dict    ,						UpperCamelCase: Any    ,						UpperCamelCase: Union[str, Any]    ,						UpperCamelCase: List[str]    ,						UpperCamelCase: Union[str, Any]    ,						UpperCamelCase: Any       ):






         """simple docstring"""


         A__										=  self.num_choices
         A__										=  TFConvBertForMultipleChoice(config=UpperCamelCase       )
         A__										=  tf.tile(tf.expand_dims(UpperCamelCase    ,						1       )    ,						(1, self.num_choices, 1)       )
         A__										=  tf.tile(tf.expand_dims(UpperCamelCase    ,						1       )    ,						(1, self.num_choices, 1)       )
         A__										=  tf.tile(tf.expand_dims(UpperCamelCase    ,						1       )    ,						(1, self.num_choices, 1)       )
         A__										=  {
             """input_ids""": multiple_choice_inputs_ids,
             """attention_mask""": multiple_choice_input_mask,
             """token_type_ids""": multiple_choice_token_type_ids,
         }
         A__										=  model(UpperCamelCase       )
         self.parent.assertEqual(result.logits.shape    ,						(self.batch_size, self.num_choices)       )

    def 				UpperCamelCase	(     self: List[str]    ,						UpperCamelCase: Tuple    ,						UpperCamelCase: Optional[Any]    ,						UpperCamelCase: List[str]    ,						UpperCamelCase: List[Any]    ,						UpperCamelCase: str    ,						UpperCamelCase: List[str]    ,						UpperCamelCase: Optional[Any]       ):






         """simple docstring"""


         A__										=  self.num_labels
         A__										=  TFConvBertForTokenClassification(config=UpperCamelCase       )
         A__										=  {
             """input_ids""": input_ids,
             """attention_mask""": input_mask,
             """token_type_ids""": token_type_ids,
         }
         A__										=  model(UpperCamelCase       )
         self.parent.assertEqual(result.logits.shape    ,						(self.batch_size, self.seq_length, self.num_labels)       )

    def 				UpperCamelCase	(     self: Dict    ,						UpperCamelCase: Dict    ,						UpperCamelCase: List[str]    ,						UpperCamelCase: Union[str, Any]    ,						UpperCamelCase: Tuple    ,						UpperCamelCase: Union[str, Any]    ,						UpperCamelCase: Any    ,						UpperCamelCase: Dict       ):






         """simple docstring"""


         A__										=  TFConvBertForQuestionAnswering(config=UpperCamelCase       )
         A__										=  {
             """input_ids""": input_ids,
             """attention_mask""": input_mask,
             """token_type_ids""": token_type_ids,
         }

         A__										=  model(UpperCamelCase       )
         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: Tuple       ):






         """simple docstring"""


         A__										=  self.prepare_config_and_inputs()
         (
             (
             A__
         )			,				(
             A__
         )			,				(
             A__
         )			,				(
             A__
         )			,				(
             A__
         )			,				(
             A__
         )			,				(
             A__
         )			,				
         )										=  config_and_inputs
         A__										=  {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
         return config, inputs_dict



@require_tf
class 					a						(       _lowerCamelCase,	_lowerCamelCase,	unittest.TestCase				):



    """simple docstring"""



    UpperCAmelCase						 =					(
        (
            TFConvBertModel,
            TFConvBertForMaskedLM,
            TFConvBertForQuestionAnswering,
            TFConvBertForSequenceClassification,
            TFConvBertForTokenClassification,
            TFConvBertForMultipleChoice,
        )
        if is_tf_available()
        else ()
    )
    UpperCAmelCase						 =					(
        {
            "feature-extraction": TFConvBertModel,
            "fill-mask": TFConvBertForMaskedLM,
            "question-answering": TFConvBertForQuestionAnswering,
            "text-classification": TFConvBertForSequenceClassification,
            "token-classification": TFConvBertForTokenClassification,
            "zero-shot": TFConvBertForSequenceClassification,
        }
        if is_tf_available()
        else {}
    )
    UpperCAmelCase						 =					False
    UpperCAmelCase						 =					False
    UpperCAmelCase						 =					False

    def 				UpperCamelCase	(     self: Any       ):






         """simple docstring"""


         A__										=  TFConvBertModelTester(self       )
         A__										=  ConfigTester(self    ,						config_class=UpperCamelCase    ,						hidden_size=37       )

    def 				UpperCamelCase	(     self: str       ):






         """simple docstring"""


         self.config_tester.run_common_tests()

    def 				UpperCamelCase	(     self: Any       ):






         """simple docstring"""


         A__										=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*UpperCamelCase       )

    def 				UpperCamelCase	(     self: Optional[int]       ):






         """simple docstring"""


         A__										=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_lm(*UpperCamelCase       )

    def 				UpperCamelCase	(     self: Any       ):






         """simple docstring"""


         A__										=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_multiple_choice(*UpperCamelCase       )

    def 				UpperCamelCase	(     self: Optional[Any]       ):






         """simple docstring"""


         A__										=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*UpperCamelCase       )

    def 				UpperCamelCase	(     self: Optional[Any]       ):






         """simple docstring"""


         A__										=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_sequence_classification(*UpperCamelCase       )

    def 				UpperCamelCase	(     self: Dict       ):






         """simple docstring"""


         A__										=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*UpperCamelCase       )

    @slow
    def 				UpperCamelCase	(     self: List[Any]       ):






         """simple docstring"""


         A__			,				A__										=  self.model_tester.prepare_config_and_inputs_for_common()
         A__										=  True
         A__										=  True

         if hasattr(UpperCamelCase    ,						"""use_cache"""       ):
              A__										=  True

         A__										=  getattr(self.model_tester    ,						"""encoder_seq_length"""    ,						self.model_tester.seq_length       )
         A__										=  getattr(self.model_tester    ,						"""key_length"""    ,						UpperCamelCase       )

         for model_class in self.all_model_classes:
              A__										=  self._prepare_for_class(UpperCamelCase    ,						UpperCamelCase       )
              A__										=  model_class(UpperCamelCase       )
              A__										=  len(model(UpperCamelCase       )       )

              with tempfile.TemporaryDirectory() as tmpdirname:
                   model.save_pretrained(UpperCamelCase    ,						saved_model=UpperCamelCase       )
                   A__										=  os.path.join(UpperCamelCase    ,						"""saved_model"""    ,						"""1"""       )
                   A__										=  tf.keras.models.load_model(UpperCamelCase       )
                   A__										=  model(UpperCamelCase       )

                   if self.is_encoder_decoder:
                        A__										=  outputs["""encoder_hidden_states"""]
                        A__										=  outputs["""encoder_attentions"""]
                   else:
                        A__										=  outputs["""hidden_states"""]
                        A__										=  outputs["""attentions"""]

                   self.assertEqual(len(UpperCamelCase       )    ,						UpperCamelCase       )

                   A__										=  getattr(
                       self.model_tester    ,						"""expected_num_hidden_layers"""    ,						self.model_tester.num_hidden_layers + 1       )

                   self.assertEqual(len(UpperCamelCase       )    ,						UpperCamelCase       )
                   self.assertListEqual(
                       list(output_hidden_states[0].shape[-2:]       )    ,						[self.model_tester.seq_length, self.model_tester.hidden_size]    ,						)

                   self.assertEqual(len(UpperCamelCase       )    ,						self.model_tester.num_hidden_layers       )
                   self.assertListEqual(
                       list(output_attentions[0].shape[-3:]       )    ,						[self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length]    ,						)

    @slow
    def 				UpperCamelCase	(     self: List[str]       ):






         """simple docstring"""


         A__										=  TFConvBertModel.from_pretrained("""YituTech/conv-bert-base"""       )
         self.assertIsNotNone(UpperCamelCase       )





    def 				UpperCamelCase	(     self: Optional[int]       ):






         """simple docstring"""


         A__			,				A__										=  self.model_tester.prepare_config_and_inputs_for_common()
         A__										=  True
         A__										=  getattr(self.model_tester    ,						"""decoder_seq_length"""    ,						self.model_tester.seq_length       )
         A__										=  getattr(self.model_tester    ,						"""encoder_seq_length"""    ,						self.model_tester.seq_length       )
         A__										=  getattr(self.model_tester    ,						"""key_length"""    ,						UpperCamelCase       )
         A__										=  getattr(self.model_tester    ,						"""key_length"""    ,						UpperCamelCase       )

         def check_decoder_attentions_output(UpperCamelCase: Any       ):
              A__										=  len(UpperCamelCase       )
              self.assertEqual(out_len % 2    ,						0       )
              A__										=  outputs.decoder_attentions
              self.assertEqual(len(UpperCamelCase       )    ,						self.model_tester.num_hidden_layers       )
              self.assertListEqual(
                  list(decoder_attentions[0].shape[-3:]       )    ,						[self.model_tester.num_attention_heads / 2, decoder_seq_length, decoder_key_length]    ,						)

         def check_encoder_attentions_output(UpperCamelCase: Tuple       ):
              A__										=  [
                  t.numpy() for t in (outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions)
              ]
              self.assertEqual(len(UpperCamelCase       )    ,						self.model_tester.num_hidden_layers       )
              self.assertListEqual(
                  list(attentions[0].shape[-3:]       )    ,						[self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length]    ,						)

         for model_class in self.all_model_classes:
              A__										=  True
              A__										=  False
              A__										=  model_class(UpperCamelCase       )
              A__										=  model(self._prepare_for_class(UpperCamelCase    ,						UpperCamelCase       )       )
              A__										=  len(UpperCamelCase       )
              self.assertEqual(config.output_hidden_states    ,						UpperCamelCase       )
              check_encoder_attentions_output(UpperCamelCase       )

              if self.is_encoder_decoder:
                   A__										=  model_class(UpperCamelCase       )
                   A__										=  model(self._prepare_for_class(UpperCamelCase    ,						UpperCamelCase       )       )
                   self.assertEqual(config.output_hidden_states    ,						UpperCamelCase       )
                   check_decoder_attentions_output(UpperCamelCase       )

              # Check that output attentions can also be changed via the config
              del inputs_dict["output_attentions"]
              A__										=  True
              A__										=  model_class(UpperCamelCase       )
              A__										=  model(self._prepare_for_class(UpperCamelCase    ,						UpperCamelCase       )       )
              self.assertEqual(config.output_hidden_states    ,						UpperCamelCase       )
              check_encoder_attentions_output(UpperCamelCase       )

              # Check attention is always last and order is fine
              A__										=  True
              A__										=  True
              A__										=  model_class(UpperCamelCase       )
              A__										=  model(self._prepare_for_class(UpperCamelCase    ,						UpperCamelCase       )       )

              self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1)    ,						len(UpperCamelCase       )       )
              self.assertEqual(model.config.output_hidden_states    ,						UpperCamelCase       )
              check_encoder_attentions_output(UpperCamelCase       )



@require_tf
class 					a						(       unittest.TestCase				):



    """simple docstring"""



    @slow
    def 				UpperCamelCase	(     self: str       ):






         """simple docstring"""


         A__										=  TFConvBertModel.from_pretrained("""YituTech/conv-bert-base"""       )
         A__										=  tf.constant([[0, 1, 2, 3, 4, 5]]       )
         A__										=  model(UpperCamelCase       )[0]

         A__										=  [1, 6, 7_68]
         self.assertEqual(output.shape    ,						UpperCamelCase       )

         A__										=  tf.constant(
             [
                 [
                     [-0.03_475_493, -0.4_686_034, -0.30_638_832],
                     [0.22_637_248, -0.26_988_646, -0.7_423_424],
                     [0.10_324_868, -0.45_013_508, -0.58_280_784],
                 ]
             ]       )
         tf.debugging.assert_near(output[:, :3, :3]    ,						UpperCamelCase    ,						atol=1e-4       )









"""simple docstring"""



def  _snake_case     (    UpperCAmelCase_  :					Optional[Any]					,   UpperCAmelCase_  :					Optional[Any]			):
     A__										=  [0 for i in range(r + 1			)]
     # nc0 = 1
     A__										=  1
     for i in range(1					,   n + 1			):
          # to compute current row from previous row.
          A__										=  min(UpperCAmelCase_					,   UpperCAmelCase_			)
          while j > 0:
               c[j] += c[j - 1]
               j -= 1
     return c[r]

print(binomial_coefficient(n=1_0, r=5))






