





'''simple docstring'''




import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

import diffusers
from diffusers import (
    AutoencoderKL,
    EulerDiscreteScheduler,
    StableDiffusionLatentUpscalePipeline,
    StableDiffusionPipeline,
    UNetaDConditionModel,
)
from diffusers.schedulers import KarrasDiffusionSchedulers
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()






def 			_lowerCAmelCase     (    __snake_case    :					Union[str, Any]     )	->	Optional[int]:
     __A		:					str						=			[tensor.shape for tensor in tensor_list]
     return all(shape == shapes[0] for shape in shapes[1:]     )


class 					SCREAMING_SNAKE_CASE       (a__   ,						a__   ,						a__   ,						unittest.TestCase				):
     lowerCAmelCase						     =			StableDiffusionLatentUpscalePipeline
     lowerCAmelCase						     =			TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
         '''height''',
         '''width''',
         '''cross_attention_kwargs''',
         '''negative_prompt_embeds''',
         '''prompt_embeds''',
     }
     lowerCAmelCase						     =			PipelineTesterMixin.required_optional_params - {'''num_images_per_prompt'''}
     lowerCAmelCase						     =			TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
     lowerCAmelCase						     =			frozenset(
         []				)  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
     lowerCAmelCase						     =			frozenset([]				)

     lowerCAmelCase						     =			True


     @property
     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Optional[int]						=			1
          __A		:					str						=			4
          __A		:					Dict						=			(16, 16)

          __A		:					List[Any]						=			floats_tensor((batch_size, num_channels) + sizes		,      rng=random.Random(0)).to(_UpperCAmelCase)
          return image


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          torch.manual_seed(0)
          __A		:					Dict						=			UNetaDConditionModel(
              act_fn='gelu'		,      attention_head_dim=8		,      norm_num_groups=_UpperCAmelCase		,      block_out_channels=[32, 32, 64, 64]		,      time_cond_proj_dim=160		,      conv_in_kernel=1		,      conv_out_kernel=1		,      cross_attention_dim=32		,      down_block_types=(
                  'KDownBlock2D',
                  'KCrossAttnDownBlock2D',
                  'KCrossAttnDownBlock2D',
                  'KCrossAttnDownBlock2D',
              )		,      in_channels=8		,      mid_block_type=_UpperCAmelCase		,      only_cross_attention=_UpperCAmelCase		,      out_channels=5		,      resnet_time_scale_shift='scale_shift'		,      time_embedding_type='fourier'		,      timestep_post_act='gelu'		,      up_block_types=('KCrossAttnUpBlock2D', 'KCrossAttnUpBlock2D', 'KCrossAttnUpBlock2D', 'KUpBlock2D')		,      )
          __A		:					int						=			AutoencoderKL(
              block_out_channels=[32, 32, 64, 64]		,      in_channels=3		,      out_channels=3		,      down_block_types=[
                  'DownEncoderBlock2D',
                  'DownEncoderBlock2D',
                  'DownEncoderBlock2D',
                  'DownEncoderBlock2D',
              ]		,      up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D']		,      latent_channels=4		,      )
          __A		:					List[Any]						=			EulerDiscreteScheduler(prediction_type='sample')
          __A		:					Union[str, Any]						=			CLIPTextConfig(
              bos_token_id=0		,      eos_token_id=2		,      hidden_size=32		,      intermediate_size=37		,      layer_norm_eps=1e-0_5		,      num_attention_heads=4		,      num_hidden_layers=5		,      pad_token_id=1		,      vocab_size=1000		,      hidden_act='quick_gelu'		,      projection_dim=512		,      )
          __A		:					List[str]						=			CLIPTextModel(_UpperCAmelCase)
          __A		:					Union[str, Any]						=			CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

          __A		:					List[str]						=			{
              'unet': model.eval(),
              'vae': vae.eval(),
              'scheduler': scheduler,
              'text_encoder': text_encoder,
              'tokenizer': tokenizer,
          }

          return components


     def 				SCREAMING_SNAKE_CASE    (		self		,      _UpperCAmelCase		,      _UpperCAmelCase=0):

          '''simple docstring'''






          if str(_UpperCAmelCase).startswith('mps'):
               __A		:					Optional[Any]						=			torch.manual_seed(_UpperCAmelCase)
          else:
               __A		:					Tuple						=			torch.Generator(device=_UpperCAmelCase).manual_seed(_UpperCAmelCase)
          __A		:					List[str]						=			{
              'prompt': 'A painting of a squirrel eating a burger',
              'image': self.dummy_image.cpu(),
              'generator': generator,
              'num_inference_steps': 2,
              'output_type': 'numpy',
          }
          return inputs


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Optional[Any]						=			'cpu'

          __A		:					str						=			self.get_dummy_components()
          __A		:					Optional[Any]						=			self.pipeline_class(**_UpperCAmelCase)
          pipe.to(_UpperCAmelCase)
          pipe.set_progress_bar_config(disable=_UpperCAmelCase)

          __A		:					Optional[Any]						=			self.get_dummy_inputs(_UpperCAmelCase)
          __A		:					List[str]						=			pipe(**_UpperCAmelCase).images
          __A		:					Union[str, Any]						=			image[0, -3:, -3:, -1]

          self.assertEqual(image.shape		,      (1, 256, 256, 3))
          __A		:					Any						=			np.array(
              [0.47222412, 0.41921633, 0.44717434, 0.46874192, 0.42588258, 0.46150726, 0.4677534, 0.45583832, 0.48579055])
          __A		:					List[Any]						=			np.abs(image_slice.flatten() - expected_slice).max()
          self.assertLessEqual(_UpperCAmelCase		,      1e-3)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          super().test_attention_slicing_forward_pass(expected_max_diff=7e-3)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          super().test_cpu_offload_forward_pass(expected_max_diff=3e-3)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          super().test_inference_batch_single_identical(expected_max_diff=7e-3)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          super().test_pt_np_pil_outputs_equivalent(expected_max_diff=3e-3)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          super().test_save_load_local(expected_max_difference=3e-3)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          super().test_save_load_optional_components(expected_max_difference=3e-3)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Tuple						=			[
              'DDIMScheduler',
              'DDPMScheduler',
              'PNDMScheduler',
              'HeunDiscreteScheduler',
              'EulerAncestralDiscreteScheduler',
              'KDPM2DiscreteScheduler',
              'KDPM2AncestralDiscreteScheduler',
              'DPMSolverSDEScheduler',
          ]
          __A		:					int						=			self.get_dummy_components()
          __A		:					Union[str, Any]						=			self.pipeline_class(**_UpperCAmelCase)

          # make sure that PNDM does not need warm-up
          pipe.scheduler.register_to_config(skip_prk_steps=_UpperCAmelCase)

          pipe.to(_UpperCAmelCase)
          pipe.set_progress_bar_config(disable=_UpperCAmelCase)
          __A		:					int						=			self.get_dummy_inputs(_UpperCAmelCase)
          __A		:					Union[str, Any]						=			2

          __A		:					List[str]						=			[]
          for scheduler_enum in KarrasDiffusionSchedulers:
               if scheduler_enum.name in skip_schedulers:
                    # no sigma schedulers are not supported
                    # no schedulers
                    continue

               __A		:					List[str]						=			getattr(_UpperCAmelCase		,      scheduler_enum.name)
               __A		:					Optional[Any]						=			scheduler_cls.from_config(pipe.scheduler.config)
               __A		:					Any						=			pipe(**_UpperCAmelCase)[0]
               outputs.append(_UpperCAmelCase)

          assert check_same_shape(_UpperCAmelCase)




@require_torch_gpu
@slow
class 					SCREAMING_SNAKE_CASE       (unittest.TestCase				):


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					str						=			torch.manual_seed(33)

          __A		:					List[str]						=			StableDiffusionPipeline.from_pretrained('CompVis/stable-diffusion-v1-4'		,      torch_dtype=torch.floataa)
          pipe.to('cuda')

          __A		:					List[Any]						=			StableDiffusionLatentUpscalePipeline.from_pretrained(
              'stabilityai/sd-x2-latent-upscaler'		,      torch_dtype=torch.floataa)
          upscaler.to('cuda')

          __A		:					Any						=			'a photo of an astronaut high resolution, unreal engine, ultra realistic'

          __A		:					Any						=			pipe(_UpperCAmelCase		,      generator=_UpperCAmelCase		,      output_type='latent').images

          __A		:					int						=			upscaler(
              prompt=_UpperCAmelCase		,      image=_UpperCAmelCase		,      num_inference_steps=20		,      guidance_scale=0		,      generator=_UpperCAmelCase		,      output_type='np'		,      ).images[0]

          __A		:					Optional[Any]						=			load_numpy(
              'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/astronaut_1024.npy')
          assert np.abs((expected_image - image).mean()) < 5e-2


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Union[str, Any]						=			torch.manual_seed(33)

          __A		:					Union[str, Any]						=			StableDiffusionLatentUpscalePipeline.from_pretrained(
              'stabilityai/sd-x2-latent-upscaler'		,      torch_dtype=torch.floataa)
          upscaler.to('cuda')

          __A		:					Any						=			'the temple of fire by Ross Tran and Gerardo Dottori, oil on canvas'

          __A		:					Dict						=			load_image(
              'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/fire_temple_512.png')

          __A		:					int						=			upscaler(
              prompt=_UpperCAmelCase		,      image=_UpperCAmelCase		,      num_inference_steps=20		,      guidance_scale=0		,      generator=_UpperCAmelCase		,      output_type='np'		,      ).images[0]

          __A		:					List[Any]						=			load_numpy(
              'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/fire_temple_1024.npy')
          assert np.abs((expected_image - image).max()) < 5e-2






'''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 					SCREAMING_SNAKE_CASE       :


     def __init__(		self		,      _UpperCAmelCase		,      _UpperCAmelCase=13		,      _UpperCAmelCase=7		,      _UpperCAmelCase=True		,      _UpperCAmelCase=True		,      _UpperCAmelCase=True		,      _UpperCAmelCase=True		,      _UpperCAmelCase=99		,      _UpperCAmelCase=32		,      _UpperCAmelCase=2		,      _UpperCAmelCase=4		,      _UpperCAmelCase=37		,      _UpperCAmelCase="gelu"		,      _UpperCAmelCase=0.1		,      _UpperCAmelCase=0.1		,      _UpperCAmelCase=512		,      _UpperCAmelCase=16		,      _UpperCAmelCase=2		,      _UpperCAmelCase=0.02		,      _UpperCAmelCase=3		,      _UpperCAmelCase=4		,      _UpperCAmelCase=None		,      ):

          '''simple docstring'''






          __A		:					Optional[int]						=			parent
          __A		:					str						=			13
          __A		:					List[Any]						=			7
          __A		:					List[str]						=			True
          __A		:					str						=			True
          __A		:					Optional[Any]						=			True
          __A		:					int						=			True
          __A		:					Dict						=			99
          __A		:					Dict						=			384
          __A		:					Any						=			2
          __A		:					int						=			4
          __A		:					Optional[Any]						=			37
          __A		:					Optional[int]						=			'gelu'
          __A		:					Dict						=			0.1
          __A		:					Optional[int]						=			0.1
          __A		:					Any						=			512
          __A		:					int						=			16
          __A		:					List[str]						=			2
          __A		:					str						=			0.02
          __A		:					Any						=			3
          __A		:					str						=			4
          __A		:					Union[str, Any]						=			128
          __A		:					int						=			2
          __A		:					List[Any]						=			9
          __A		:					List[Any]						=			1
          __A		:					List[Any]						=			None


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Union[str, Any]						=			ids_tensor([self.batch_size, self.seq_length]		,      self.vocab_size)

          __A		:					str						=			None
          if self.use_input_mask:
               __A		:					List[Any]						=			random_attention_mask([self.batch_size, self.seq_length])

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

          __A		:					Optional[int]						=			None
          __A		:					List[str]						=			None
          __A		:					Dict						=			None
          if self.use_labels:
               __A		:					Dict						=			ids_tensor([self.batch_size]		,      self.type_sequence_label_size)
               __A		:					List[Any]						=			ids_tensor([self.batch_size, self.seq_length]		,      self.num_labels)
               __A		:					str						=			ids_tensor([self.batch_size]		,      self.num_choices)

          __A		:					List[Any]						=			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 				SCREAMING_SNAKE_CASE    (		self		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase):

          '''simple docstring'''






          __A		:					int						=			TFConvBertModel(config=_UpperCAmelCase)
          __A		:					Optional[Any]						=			{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}

          __A		:					Tuple						=			[input_ids, input_mask]
          __A		:					Any						=			model(_UpperCAmelCase)

          __A		:					Dict						=			model(_UpperCAmelCase)

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


     def 				SCREAMING_SNAKE_CASE    (		self		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase):

          '''simple docstring'''






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


     def 				SCREAMING_SNAKE_CASE    (		self		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase):

          '''simple docstring'''






          __A		:					Optional[int]						=			self.num_labels
          __A		:					Any						=			TFConvBertForSequenceClassification(config=_UpperCAmelCase)
          __A		:					Optional[Any]						=			{
              'input_ids': input_ids,
              'attention_mask': input_mask,
              'token_type_ids': token_type_ids,
          }

          __A		:					Dict						=			model(_UpperCAmelCase)
          self.parent.assertEqual(result.logits.shape		,      (self.batch_size, self.num_labels))


     def 				SCREAMING_SNAKE_CASE    (		self		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase):

          '''simple docstring'''






          __A		:					Tuple						=			self.num_choices
          __A		:					List[str]						=			TFConvBertForMultipleChoice(config=_UpperCAmelCase)
          __A		:					int						=			tf.tile(tf.expand_dims(_UpperCAmelCase		,      1)		,      (1, self.num_choices, 1))
          __A		:					Optional[Any]						=			tf.tile(tf.expand_dims(_UpperCAmelCase		,      1)		,      (1, self.num_choices, 1))
          __A		:					List[Any]						=			tf.tile(tf.expand_dims(_UpperCAmelCase		,      1)		,      (1, self.num_choices, 1))
          __A		:					int						=			{
              'input_ids': multiple_choice_inputs_ids,
              'attention_mask': multiple_choice_input_mask,
              'token_type_ids': multiple_choice_token_type_ids,
          }
          __A		:					Optional[Any]						=			model(_UpperCAmelCase)
          self.parent.assertEqual(result.logits.shape		,      (self.batch_size, self.num_choices))


     def 				SCREAMING_SNAKE_CASE    (		self		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase):

          '''simple docstring'''






          __A		:					List[Any]						=			self.num_labels
          __A		:					List[Any]						=			TFConvBertForTokenClassification(config=_UpperCAmelCase)
          __A		:					str						=			{
              'input_ids': input_ids,
              'attention_mask': input_mask,
              'token_type_ids': token_type_ids,
          }
          __A		:					int						=			model(_UpperCAmelCase)
          self.parent.assertEqual(result.logits.shape		,      (self.batch_size, self.seq_length, self.num_labels))


     def 				SCREAMING_SNAKE_CASE    (		self		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase		,      _UpperCAmelCase):

          '''simple docstring'''






          __A		:					Optional[Any]						=			TFConvBertForQuestionAnswering(config=_UpperCAmelCase)
          __A		:					Any						=			{
              'input_ids': input_ids,
              'attention_mask': input_mask,
              'token_type_ids': token_type_ids,
          }

          __A		:					Union[str, Any]						=			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 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Optional[int]						=			self.prepare_config_and_inputs()
          (
              (
              __A
          )					,(
              __A
          )					,(
              __A
          )					,(
              __A
          )					,(
              __A
          )					,(
              __A
          )					,(
              __A
          )					,
          )		:					Union[str, Any]						=			config_and_inputs
          __A		:					List[str]						=			{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
          return config, inputs_dict




@require_tf
class 					SCREAMING_SNAKE_CASE       (a__   ,						a__   ,						unittest.TestCase				):
     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 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					int						=			TFConvBertModelTester(self)
          __A		:					str						=			ConfigTester(self		,      config_class=_UpperCAmelCase		,      hidden_size=37)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          self.config_tester.run_common_tests()


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Tuple						=			self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*_UpperCAmelCase)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					str						=			self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_lm(*_UpperCAmelCase)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Optional[Any]						=			self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_multiple_choice(*_UpperCAmelCase)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					List[Any]						=			self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_question_answering(*_UpperCAmelCase)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					int						=			self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_sequence_classification(*_UpperCAmelCase)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					int						=			self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_token_classification(*_UpperCAmelCase)


     @slow
     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A					,__A		:					Union[str, Any]						=			self.model_tester.prepare_config_and_inputs_for_common()
          __A		:					List[str]						=			True
          __A		:					List[str]						=			True

          if hasattr(_UpperCAmelCase		,      'use_cache'):
               __A		:					List[Any]						=			True

          __A		:					str						=			getattr(self.model_tester		,      'encoder_seq_length'		,      self.model_tester.seq_length)
          __A		:					Union[str, Any]						=			getattr(self.model_tester		,      'key_length'		,      _UpperCAmelCase)

          for model_class in self.all_model_classes:
               __A		:					List[str]						=			self._prepare_for_class(_UpperCAmelCase		,      _UpperCAmelCase)
               __A		:					Optional[int]						=			model_class(_UpperCAmelCase)
               __A		:					Optional[Any]						=			len(model(_UpperCAmelCase))

               with tempfile.TemporaryDirectory() as tmpdirname:
                    model.save_pretrained(_UpperCAmelCase		,      saved_model=_UpperCAmelCase)
                    __A		:					Union[str, Any]						=			os.path.join(_UpperCAmelCase		,      'saved_model'		,      '1')
                    __A		:					Tuple						=			tf.keras.models.load_model(_UpperCAmelCase)
                    __A		:					str						=			model(_UpperCAmelCase)

                    if self.is_encoder_decoder:
                         __A		:					Optional[int]						=			outputs['encoder_hidden_states']
                         __A		:					str						=			outputs['encoder_attentions']
                    else:
                         __A		:					List[Any]						=			outputs['hidden_states']
                         __A		:					Optional[Any]						=			outputs['attentions']

                    self.assertEqual(len(_UpperCAmelCase)		,      _UpperCAmelCase)

                    __A		:					str						=			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 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Dict						=			TFConvBertModel.from_pretrained('YituTech/conv-bert-base')
          self.assertIsNotNone(_UpperCAmelCase)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A					,__A		:					Dict						=			self.model_tester.prepare_config_and_inputs_for_common()
          __A		:					Any						=			True
          __A		:					str						=			getattr(self.model_tester		,      'decoder_seq_length'		,      self.model_tester.seq_length)
          __A		:					Any						=			getattr(self.model_tester		,      'encoder_seq_length'		,      self.model_tester.seq_length)
          __A		:					int						=			getattr(self.model_tester		,      'key_length'		,      _UpperCAmelCase)
          __A		:					Tuple						=			getattr(self.model_tester		,      'key_length'		,      _UpperCAmelCase)

          def check_decoder_attentions_output(_UpperCAmelCase):
               __A		:					List[str]						=			len(_UpperCAmelCase)
               self.assertEqual(out_len % 2		,      0)
               __A		:					Any						=			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):
               __A		:					str						=			[
                   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		:					Dict						=			True
               __A		:					Any						=			False
               __A		:					str						=			model_class(_UpperCAmelCase)
               __A		:					List[str]						=			model(self._prepare_for_class(_UpperCAmelCase		,      _UpperCAmelCase))
               __A		:					List[str]						=			len(_UpperCAmelCase)
               self.assertEqual(config.output_hidden_states		,      _UpperCAmelCase)
               check_encoder_attentions_output(_UpperCAmelCase)

               if self.is_encoder_decoder:
                    __A		:					Union[str, Any]						=			model_class(_UpperCAmelCase)
                    __A		:					int						=			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		:					int						=			True
               __A		:					Tuple						=			model_class(_UpperCAmelCase)
               __A		:					Dict						=			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		:					Any						=			True
               __A		:					str						=			True
               __A		:					Union[str, Any]						=			model_class(_UpperCAmelCase)
               __A		:					Union[str, Any]						=			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 					SCREAMING_SNAKE_CASE       (unittest.TestCase				):


     @slow
     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Tuple						=			TFConvBertModel.from_pretrained('YituTech/conv-bert-base')
          __A		:					str						=			tf.constant([[0, 1, 2, 3, 4, 5]])
          __A		:					Optional[int]						=			model(_UpperCAmelCase)[0]

          __A		:					List[Any]						=			[1, 6, 768]
          self.assertEqual(output.shape		,      _UpperCAmelCase)

          __A		:					Tuple						=			tf.constant(
              [
                  [
                      [-0.03475493, -0.4686034, -0.30638832],
                      [0.22637248, -0.26988646, -0.7423424],
                      [0.10324868, -0.45013508, -0.58280784],
                  ]
              ])
          tf.debugging.assert_near(output[:, :3, :3]		,      _UpperCAmelCase		,      atol=1e-4)