

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 :       Union[str, Any],lowercase_ :       int,lowercase_ :       Union[str, Any]=1_3,lowercase_ :       List[str]=7,lowercase_ :       Tuple=True,lowercase_ :       List[str]=True,lowercase_ :       List[str]=True,lowercase_ :       List[str]=True,lowercase_ :       Tuple=9_9,lowercase_ :       Union[str, Any]=3_2,lowercase_ :       str=2,lowercase_ :       Optional[Any]=4,lowercase_ :       Optional[int]=3_7,lowercase_ :       int="gelu",lowercase_ :       Any=0.1,lowercase_ :       Optional[int]=0.1,lowercase_ :       List[str]=5_1_2,lowercase_ :       int=1_6,lowercase_ :       Dict=2,lowercase_ :       Any=0.02,lowercase_ :       Union[str, Any]=3,lowercase_ :       Dict=4,lowercase_ :       Dict=None,)->    Optional[int]:





        '''simple docstring'''







        A__          =   parent
        A__          =   1_3
        A__          =   7
        A__          =   True
        A__          =   True
        A__          =   True
        A__          =   True
        A__          =   9_9
        A__          =   3_8_4
        A__          =   2
        A__          =   4
        A__          =   3_7
        A__          =   'gelu'
        A__          =   0.1
        A__          =   0.1
        A__          =   5_1_2
        A__          =   1_6
        A__          =   2
        A__          =   0.02
        A__          =   3
        A__          =   4
        A__          =   1_2_8
        A__          =   2
        A__          =   9
        A__          =   1
        A__          =   None


    def 						snake_case__     (      self :       Any		)->    Optional[int]:





        '''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=lowercase_,)

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


    def 						snake_case__     (      self :       List[Any],lowercase_ :       Optional[Any],lowercase_ :       List[str],lowercase_ :       str,lowercase_ :       Optional[Any],lowercase_ :       int,lowercase_ :       Union[str, Any],lowercase_ :       Dict		)->    List[Any]:





        '''simple docstring'''







        A__          =   TFConvBertModel(config=lowercase_		)
        A__          =   {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}

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

        A__          =   model(lowercase_		)

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


    def 						snake_case__     (      self :       Union[str, Any],lowercase_ :       Optional[Any],lowercase_ :       int,lowercase_ :       Any,lowercase_ :       Any,lowercase_ :       Optional[Any],lowercase_ :       Tuple,lowercase_ :       Optional[Any]		)->    Tuple:





        '''simple docstring'''







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


    def 						snake_case__     (      self :       List[Any],lowercase_ :       List[str],lowercase_ :       Tuple,lowercase_ :       Optional[int],lowercase_ :       Any,lowercase_ :       Dict,lowercase_ :       str,lowercase_ :       str		)->    Union[str, Any]:





        '''simple docstring'''







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

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


    def 						snake_case__     (      self :       List[str],lowercase_ :       Tuple,lowercase_ :       Optional[int],lowercase_ :       List[str],lowercase_ :       List[Any],lowercase_ :       Dict,lowercase_ :       List[str],lowercase_ :       Dict		)->    int:





        '''simple docstring'''







        A__          =   self.num_choices
        A__          =   TFConvBertForMultipleChoice(config=lowercase_		)
        A__          =   tf.tile(tf.expand_dims(lowercase_,1		),(1, self.num_choices, 1)		)
        A__          =   tf.tile(tf.expand_dims(lowercase_,1		),(1, self.num_choices, 1)		)
        A__          =   tf.tile(tf.expand_dims(lowercase_,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(lowercase_		)
        self.parent.assertEqual(result.logits.shape,(self.batch_size, self.num_choices)		)


    def 						snake_case__     (      self :       int,lowercase_ :       int,lowercase_ :       Dict,lowercase_ :       List[Any],lowercase_ :       Dict,lowercase_ :       List[Any],lowercase_ :       Optional[Any],lowercase_ :       Optional[Any]		)->    Dict:





        '''simple docstring'''







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


    def 						snake_case__     (      self :       str,lowercase_ :       Optional[Any],lowercase_ :       Optional[Any],lowercase_ :       Optional[Any],lowercase_ :       List[Any],lowercase_ :       Any,lowercase_ :       Union[str, Any],lowercase_ :       Dict		)->    Tuple:





        '''simple docstring'''







        A__          =   TFConvBertForQuestionAnswering(config=lowercase_		)
        A__          =   {
            'input_ids': input_ids,
            'attention_mask': input_mask,
            'token_type_ids': token_type_ids,
        }

        A__          =   model(lowercase_		)
        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 						snake_case__     (      self :       int		)->    Any:





        '''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						(							_UpperCAmelCase    ,							_UpperCAmelCase    ,							unittest.TestCase ):







    """simple docstring"""





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


    def 						snake_case__     (      self :       List[Any]		)->    Optional[int]:





        '''simple docstring'''







        A__          =   TFConvBertModelTester(self		)
        A__          =   ConfigTester(self,config_class=lowercase_,hidden_size=3_7		)


    def 						snake_case__     (      self :       Union[str, Any]		)->    List[str]:





        '''simple docstring'''







        self.config_tester.run_common_tests()


    def 						snake_case__     (      self :       Optional[Any]		)->    Any:





        '''simple docstring'''







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


    def 						snake_case__     (      self :       Any		)->    int:





        '''simple docstring'''







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


    def 						snake_case__     (      self :       Dict		)->    Optional[int]:





        '''simple docstring'''







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


    def 						snake_case__     (      self :       Tuple		)->    Tuple:





        '''simple docstring'''







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


    def 						snake_case__     (      self :       str		)->    List[str]:





        '''simple docstring'''







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


    def 						snake_case__     (      self :       Union[str, Any]		)->    Union[str, Any]:





        '''simple docstring'''







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


    @slow
    def 						snake_case__     (      self :       str		)->    Dict:





        '''simple docstring'''







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

        if hasattr(lowercase_,'use_cache'		):
            A__          =   True

        A__          =   getattr(self.model_tester,'encoder_seq_length',self.model_tester.seq_length		)
        A__          =   getattr(self.model_tester,'key_length',lowercase_		)

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

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

                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(lowercase_		),lowercase_		)

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

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

                self.assertEqual(len(lowercase_		),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 						snake_case__     (      self :       List[Any]		)->    Union[str, Any]:





        '''simple docstring'''







        A__          =   TFConvBertModel.from_pretrained('YituTech/conv-bert-base'		)
        self.assertIsNotNone(lowercase_		)


    def 						snake_case__     (      self :       Any		)->    str:





        '''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',lowercase_		)
        A__          =   getattr(self.model_tester,'key_length',lowercase_		)

        def check_decoder_attentions_output(lowercase_ :       Union[str, Any]		):
            A__          =   len(lowercase_		)
            self.assertEqual(out_len % 2,0		)
            A__          =   outputs.decoder_attentions
            self.assertEqual(len(lowercase_		),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(lowercase_ :       str		):
            A__          =   [
                t.numpy() for t in (outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions)
            ]
            self.assertEqual(len(lowercase_		),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(lowercase_		)
            A__          =   model(self._prepare_for_class(lowercase_,lowercase_		)		)
            A__          =   len(lowercase_		)
            self.assertEqual(config.output_hidden_states,lowercase_		)
            check_encoder_attentions_output(lowercase_		)

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

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

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

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




@require_tf
class  A						(							unittest.TestCase ):







    """simple docstring"""





    @slow
    def 						snake_case__     (      self :       Optional[Any]		)->    str:





        '''simple docstring'''







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

        A__          =   [1, 6, 7_6_8]
        self.assertEqual(output.shape,lowercase_		)

        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],lowercase_,atol=1E-4		)





def 							_UpperCAmelCase				(UpperCamelCase__     :  Optional[Any]				,							UpperCamelCase__     :  Union[str, Any]						):
       # "extended trapezoidal rule"
       # int(f) = dx/2 * (f1 + 2f2 + ... + fn)
       _A      :       int				    = (boundary[1] - boundary[0]) / steps
       _A      :       Any				    = boundary[0]
       _A      :       List[Any]				    = boundary[1]
       _A      :       str				    = make_points(UpperCamelCase__				,							UpperCamelCase__				,							UpperCamelCase__						)
       _A      :       str				    = 0.0
       y += (h / 2.0) * f(UpperCamelCase__						)
       for i in x_i:
              # print(i)
              y += h * f(UpperCamelCase__						)
       y += (h / 2.0) * f(UpperCamelCase__						)
       return y
def 							_UpperCAmelCase				(UpperCamelCase__     :  List[str]				,							UpperCamelCase__     :  Optional[int]				,							UpperCamelCase__     :  Any						):
       _A      :       Optional[int]				    = a + h
       while x < (b - h):
              yield x
              _A      :       Dict				    = x + h
def 							_UpperCAmelCase				(UpperCamelCase__     :  Optional[int]						):  # enter your function here
       _A      :       Any				    = (x - 0) * (x - 0)
       return y
def 							_UpperCAmelCase				():
       _A      :       Optional[Any]				    = 0.0  # Lower bound of integration
       _A      :       Optional[int]				    = 1.0  # Upper bound of integration
       _A      :       List[Any]				    = 10.0  # define number of steps or resolution
       _A      :       Any				    = [a, b]  # define boundary of integration
       _A      :       Tuple				    = method_a(UpperCamelCase__				,							UpperCamelCase__						)
       print(f"y = {y}"						)


if __name__ == "__main__":
    main()
