

"""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:       List[Any]			,  UpperCamelCase:       Dict			,  UpperCamelCase:       Optional[Any]=13			,  UpperCamelCase:       Optional[int]=7			,  UpperCamelCase:       Optional[int]=True			,  UpperCamelCase:       Any=True			,  UpperCamelCase:       Union[str, Any]=True			,  UpperCamelCase:       List[Any]=True			,  UpperCamelCase:       Optional[Any]=99			,  UpperCamelCase:       Any=32			,  UpperCamelCase:       Optional[int]=2			,  UpperCamelCase:       Optional[Any]=4			,  UpperCamelCase:       Any=37			,  UpperCamelCase:       str="gelu"			,  UpperCamelCase:       Optional[Any]=0.1			,  UpperCamelCase:       Dict=0.1			,  UpperCamelCase:       Tuple=5_12			,  UpperCamelCase:       int=16			,  UpperCamelCase:       Optional[Any]=2			,  UpperCamelCase:       Dict=0.02			,  UpperCamelCase:       Optional[int]=3			,  UpperCamelCase:       int=4			,  UpperCamelCase:       Any=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:       Tuple				):






         """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=snake_case_			,  )

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

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






         """simple docstring"""


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

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

         A__								=     model(snake_case_				)

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

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






         """simple docstring"""


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

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






         """simple docstring"""


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

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

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






         """simple docstring"""


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

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






         """simple docstring"""


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

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






         """simple docstring"""


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

         A__								=     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:       List[str]				):






         """simple docstring"""


         A__								=     self.prepare_config_and_inputs()
         (
             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"""



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






         """simple docstring"""


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

    def  UpperCamelCase		(   self:       Optional[int]				):






         """simple docstring"""


         self.config_tester.run_common_tests()

    def  UpperCamelCase		(   self:       List[Any]				):






         """simple docstring"""


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

    def  UpperCamelCase		(   self:       Optional[int]				):






         """simple docstring"""


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

    def  UpperCamelCase		(   self:       List[str]				):






         """simple docstring"""


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

    def  UpperCamelCase		(   self:       Any				):






         """simple docstring"""


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

    def  UpperCamelCase		(   self:       Optional[Any]				):






         """simple docstring"""


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

    def  UpperCamelCase		(   self:       Dict				):






         """simple docstring"""


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

    @slow
    def  UpperCamelCase		(   self:       Dict				):






         """simple docstring"""


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

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

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

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

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

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

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

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

                   self.assertEqual(len(snake_case_				)			,  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:       Dict				):






         """simple docstring"""


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





    def  UpperCamelCase		(   self:       int				):






         """simple docstring"""


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

         def check_decoder_attentions_output(UpperCamelCase:       List[str]				):
              A__								=     len(snake_case_				)
              self.assertEqual(out_len % 2			,  0				)
              A__								=     outputs.decoder_attentions
              self.assertEqual(len(snake_case_				)			,  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(snake_case_				)			,  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(snake_case_				)
              A__								=     model(self._prepare_for_class(snake_case_			,  snake_case_				)				)
              A__								=     len(snake_case_				)
              self.assertEqual(config.output_hidden_states			,  snake_case_				)
              check_encoder_attentions_output(snake_case_				)

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

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

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

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



@require_tf
class     a  (				unittest.TestCase ):



    """simple docstring"""



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






         """simple docstring"""


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

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

         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]			,  snake_case_			,  atol=1e-4				)













"""simple docstring"""




import torch

from diffusers import DiffusionPipeline

class  _UpperCAmelCase  (   UpperCAmelCase__		):



      '''simple docstring'''

      def __init__(     self					,      snake_case_					,      snake_case_  ):

        """simple docstring"""

        super().__init__()

        self.register_modules(unet=snake_case_					,      scheduler=snake_case_  )

      def __call__(     self  ):

        """simple docstring"""

        A_  :       Optional[Any]										=  torch.randn(
            (1, self.unet.config.in_channels, self.unet.config.sample_size, self.unet.config.sample_size)					,      )
        A_  :       List[str]										=  1

        A_  :       List[str]										=  self.unet(snake_case_					,      snake_case_  ).sample
        A_  :       Optional[int]										=  self.scheduler.step(snake_case_					,      snake_case_					,      snake_case_  ).prev_sample

        A_  :       List[Any]										=  scheduler_output - scheduler_output + torch.ones_like(snake_case_  )

        return result