code: 
  
  
  
  
  from __future__ import annotations
  
  import unittest
  
  from transformers import DebertaConfig, 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 (
       TFDebertaForMaskedLM,
       TFDebertaForQuestionAnswering,
       TFDebertaForSequenceClassification,
       TFDebertaForTokenClassification,
       TFDebertaModel,
   )
  
  class 						A__      :
  
  
  
  
  
  
  
      """simple docstring"""
  
      def __init__( self    ,      __snake_case    ,      __snake_case=1_3    ,      __snake_case=7    ,      __snake_case=True    ,      __snake_case=True    ,      __snake_case=True    ,      __snake_case=True    ,      __snake_case=9_9    ,      __snake_case=3_2    ,      __snake_case=2    ,      __snake_case=4    ,      __snake_case=3_7    ,      __snake_case="gelu"    ,      __snake_case=0.1    ,      __snake_case=0.1    ,      __snake_case=5_1_2    ,      __snake_case=1_6    ,      __snake_case=2    ,      __snake_case=0.02    ,      __snake_case=3    ,      __snake_case=4    ,      __snake_case=None    ,      ):
           snake_case					=       parent
           snake_case					=       1_3
           snake_case					=       7
           snake_case					=       True
           snake_case					=       True
           snake_case					=       True
           snake_case					=       True
           snake_case					=       9_9
           snake_case					=       3_2
           snake_case					=       2
           snake_case					=       4
           snake_case					=       3_7
           snake_case					=       '''gelu'''
           snake_case					=       0.1
           snake_case					=       0.1
           snake_case					=       5_1_2
           snake_case					=       1_6
           snake_case					=       False
           snake_case					=       -1
           snake_case					=       True
           snake_case					=       2
           snake_case					=       0.02
           snake_case					=       3
           snake_case					=       4
           snake_case					=       None
      def 	a_    ( self					):
           snake_case					=       ids_tensor([self.batch_size, self.seq_length]    ,      self.vocab_size					)
  
           snake_case					=       None
           if self.use_input_mask:
                snake_case					=       random_attention_mask([self.batch_size, self.seq_length]					)
  
           snake_case					=       None
           if self.use_token_type_ids:
                snake_case					=       ids_tensor([self.batch_size, self.seq_length]    ,      self.type_vocab_size					)
  
           snake_case					=       None
           snake_case					=       None
           snake_case					=       None
           if self.use_labels:
                snake_case					=       ids_tensor([self.batch_size]    ,      self.type_sequence_label_size					)
                snake_case					=       ids_tensor([self.batch_size, self.seq_length]    ,      self.num_labels					)
  
           snake_case					=       DebertaConfig(
               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    ,      relative_attention=self.relative_attention    ,      max_relative_positions=self.max_relative_positions    ,      position_biased_input=self.position_biased_input    ,      initializer_range=self.initializer_range    ,      return_dict=A_    ,      )
  
           return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
      def 	a_    ( self    ,      __snake_case    ,      __snake_case    ,      __snake_case    ,      __snake_case    ,      __snake_case    ,      __snake_case    ,      __snake_case					):
           snake_case					=       TFDebertaModel(config=A_					)
           snake_case					=       {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
  
           snake_case					=       [input_ids, input_mask]
           snake_case					=       model(A_					)
  
           snake_case					=       model(A_					)
  
           self.parent.assertEqual(result.last_hidden_state.shape    ,      (self.batch_size, self.seq_length, self.hidden_size)					)
      def 	a_    ( self    ,      __snake_case    ,      __snake_case    ,      __snake_case    ,      __snake_case    ,      __snake_case    ,      __snake_case    ,      __snake_case					):
           snake_case					=       TFDebertaForMaskedLM(config=A_					)
           snake_case					=       {
               '''input_ids''': input_ids,
               '''attention_mask''': input_mask,
               '''token_type_ids''': token_type_ids,
           }
           snake_case					=       model(A_					)
           self.parent.assertEqual(result.logits.shape    ,      (self.batch_size, self.seq_length, self.vocab_size)					)
      def 	a_    ( self    ,      __snake_case    ,      __snake_case    ,      __snake_case    ,      __snake_case    ,      __snake_case    ,      __snake_case    ,      __snake_case					):
           snake_case					=       self.num_labels
           snake_case					=       TFDebertaForSequenceClassification(config=A_					)
           snake_case					=       {
               '''input_ids''': input_ids,
               '''attention_mask''': input_mask,
               '''token_type_ids''': token_type_ids,
           }
  
           snake_case					=       model(A_					)
           self.parent.assertEqual(result.logits.shape    ,      (self.batch_size, self.num_labels)					)
      def 	a_    ( self    ,      __snake_case    ,      __snake_case    ,      __snake_case    ,      __snake_case    ,      __snake_case    ,      __snake_case    ,      __snake_case					):
           snake_case					=       self.num_labels
           snake_case					=       TFDebertaForTokenClassification(config=A_					)
           snake_case					=       {
               '''input_ids''': input_ids,
               '''attention_mask''': input_mask,
               '''token_type_ids''': token_type_ids,
           }
           snake_case					=       model(A_					)
           self.parent.assertEqual(result.logits.shape    ,      (self.batch_size, self.seq_length, self.num_labels)					)
      def 	a_    ( self    ,      __snake_case    ,      __snake_case    ,      __snake_case    ,      __snake_case    ,      __snake_case    ,      __snake_case    ,      __snake_case					):
           snake_case					=       TFDebertaForQuestionAnswering(config=A_					)
           snake_case					=       {
               '''input_ids''': input_ids,
               '''attention_mask''': input_mask,
               '''token_type_ids''': token_type_ids,
           }
  
           snake_case					=       model(A_					)
           self.parent.assertEqual(result.start_logits.shape    ,      (self.batch_size, self.seq_length)					)
           self.parent.assertEqual(result.end_logits.shape    ,      (self.batch_size, self.seq_length)					)
  
  
  
  
      def 	a_    ( self					):
           snake_case					=       self.prepare_config_and_inputs()
           (
               (
               snake_case
           )				,						(
               snake_case
           )				,						(
               snake_case
           )				,						(
               snake_case
           )				,						(
               snake_case
           )				,						(
               snake_case
           )				,						(
               snake_case
           )				,						
           )					=       config_and_inputs
           snake_case					=       {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
           return config, inputs_dict
  
  
  
  
  
  
  @require_tf
  class 						A__      (					snake_case__ ,      snake_case__ ,      unittest.TestCase			):
  
  
  
  
  
  
  
      """simple docstring"""
  
      __magic_name__    						=	(
          (
              TFDebertaModel,
              TFDebertaForMaskedLM,
              TFDebertaForQuestionAnswering,
              TFDebertaForSequenceClassification,
              TFDebertaForTokenClassification,
          )
          if is_tf_available()
          else ()
      )
      __magic_name__    						=	(
          {
              'feature-extraction': TFDebertaModel,
              'fill-mask': TFDebertaForMaskedLM,
              'question-answering': TFDebertaForQuestionAnswering,
              'text-classification': TFDebertaForSequenceClassification,
              'token-classification': TFDebertaForTokenClassification,
              'zero-shot': TFDebertaForSequenceClassification,
          }
          if is_tf_available()
          else {}
      )
  
      __magic_name__    						=	False
      __magic_name__    						=	False
      def 	a_    ( self					):
           snake_case					=       TFDebertaModelTester(self					)
           snake_case					=       ConfigTester(self    ,      config_class=A_    ,      hidden_size=3_7					)
      def 	a_    ( self					):
           self.config_tester.run_common_tests()
      def 	a_    ( self					):
           snake_case					=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*A_					)
      def 	a_    ( self					):
           snake_case					=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_masked_lm(*A_					)
      def 	a_    ( self					):
           snake_case					=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_question_answering(*A_					)
      def 	a_    ( self					):
           snake_case					=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_sequence_classification(*A_					)
      def 	a_    ( self					):
           snake_case					=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_token_classification(*A_					)
  
  
  
  
      @slow
      def 	a_    ( self					):
           snake_case					=       TFDebertaModel.from_pretrained('''kamalkraj/deberta-base'''					)
           self.assertIsNotNone(A_					)
  
  
  
  
  
  
  @require_tf
  class 						A__      (					unittest.TestCase			):
  
  
  
  
  
  
  
      """simple docstring"""
  
      @unittest.skip(reason='''Model not available yet'''					)
      def 	a_    ( self					):
           pass
  
  
  
  
      @slow
      def 	a_    ( self					):
           snake_case					=       TFDebertaModel.from_pretrained('''kamalkraj/deberta-base'''					)
           snake_case					=       tf.constant([[0, 3_1_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9, 4_6_0_7_8, 1_5_8_8, 2]]					)
           snake_case					=       tf.constant([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]					)
           snake_case					=       model(A_    ,      attention_mask=A_					)[0]
  
           snake_case					=       tf.constant(
               [
                   [
                       [-0.5985_5896, -0.8055_2566, -0.846_2135],
                       [1.448_4025, -0.9348_3794, -0.8059_3085],
                       [0.312_2741, 0.0031_6059, -1.413_1377],
                   ]
               ]					)
           tf.debugging.assert_near(output[:, 1:4, 1:4]    ,      A_    ,      atol=1E-4					)
  
  
  
  
  
style_context: 
  
  
  import gc
  import unittest
  
  import numpy as np
  import torch
  from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer
  
  from diffusers import (
      AutoencoderKL,
      DDIMParallelScheduler,
      DDPMParallelScheduler,
      StableDiffusionParadigmsPipeline,
      UNetaDConditionModel,
  )
  from diffusers.utils import slow, torch_device
  from diffusers.utils.testing_utils import (
      enable_full_determinism,
      require_torch_gpu,
  )
  
  from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
  from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin
  
  
  enable_full_determinism()
  
  class 						A__      (					snake_case__ ,      snake_case__ ,      unittest.TestCase			):
  
  
  
  
  
  
  
      """simple docstring"""
  
      __magic_name__    						=	StableDiffusionParadigmsPipeline
      __magic_name__    						=	TEXT_TO_IMAGE_PARAMS
      __magic_name__    						=	TEXT_TO_IMAGE_BATCH_PARAMS
      __magic_name__    						=	TEXT_TO_IMAGE_IMAGE_PARAMS
      __magic_name__    						=	TEXT_TO_IMAGE_IMAGE_PARAMS
      def 	a_    ( self					):
           torch.manual_seed(0					)
           snake_case					=       UNetaDConditionModel(
               block_out_channels=(3_2, 6_4)    ,      layers_per_block=2    ,      sample_size=3_2    ,      in_channels=4    ,      out_channels=4    ,      down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')    ,      up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')    ,      cross_attention_dim=3_2    ,      attention_head_dim=(2, 4)    ,      use_linear_projection=__snake_case    ,      )
           snake_case					=       DDIMParallelScheduler(
               beta_start=0.0_0085    ,      beta_end=0.012    ,      beta_schedule='''scaled_linear'''    ,      clip_sample=__snake_case    ,      set_alpha_to_one=__snake_case    ,      )
           torch.manual_seed(0					)
           snake_case					=       AutoencoderKL(
               block_out_channels=[3_2, 6_4]    ,      in_channels=3    ,      out_channels=3    ,      down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']    ,      up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']    ,      latent_channels=4    ,      sample_size=1_2_8    ,      )
           torch.manual_seed(0					)
           snake_case					=       CLIPTextConfig(
               bos_token_id=0    ,      eos_token_id=2    ,      hidden_size=3_2    ,      intermediate_size=3_7    ,      layer_norm_eps=1E-05    ,      num_attention_heads=4    ,      num_hidden_layers=5    ,      pad_token_id=1    ,      vocab_size=1_0_0_0    ,      hidden_act='''gelu'''    ,      projection_dim=5_1_2    ,      )
           snake_case					=       CLIPTextModel(__snake_case					)
           snake_case					=       CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''					)
  
           snake_case					=       {
               '''unet''': unet,
               '''scheduler''': scheduler,
               '''vae''': vae,
               '''text_encoder''': text_encoder,
               '''tokenizer''': tokenizer,
               '''safety_checker''': None,
               '''feature_extractor''': None,
           }
           return components
      def 	a_    ( self    ,      __snake_case    ,      __snake_case=0					):
           if str(__snake_case					).startswith('''mps'''					):
                snake_case					=       torch.manual_seed(__snake_case					)
           else:
                snake_case					=       torch.Generator(device=__snake_case					).manual_seed(__snake_case					)
           snake_case					=       {
               '''prompt''': '''a photograph of an astronaut riding a horse''',
               '''generator''': generator,
               '''num_inference_steps''': 1_0,
               '''guidance_scale''': 6.0,
               '''output_type''': '''numpy''',
               '''parallel''': 3,
               '''debug''': True,
           }
           return inputs
      def 	a_    ( self					):
           snake_case					=       '''cpu'''  # ensure determinism for the device-dependent torch.Generator
           snake_case					=       self.get_dummy_components()
           snake_case					=       StableDiffusionParadigmsPipeline(**__snake_case					)
           snake_case					=       sd_pipe.to(__snake_case					)
           sd_pipe.set_progress_bar_config(disable=__snake_case					)
  
           snake_case					=       self.get_dummy_inputs(__snake_case					)
           snake_case					=       sd_pipe(**__snake_case					).images
           snake_case					=       image[0, -3:, -3:, -1]
           assert image.shape == (1, 6_4, 6_4, 3)
  
           snake_case					=       np.array([0.4773, 0.5417, 0.4723, 0.4925, 0.5631, 0.4752, 0.5240, 0.4935, 0.5023]					)
  
           assert np.abs(image_slice.flatten() - expected_slice					).max() < 1E-2
      def 	a_    ( self					):
           snake_case					=       '''cpu'''  # ensure determinism for the device-dependent torch.Generator
           snake_case					=       self.get_dummy_components()
           torch.manual_seed(0					)
           snake_case					=       DDPMParallelScheduler()
           torch.manual_seed(0					)
           snake_case					=       StableDiffusionParadigmsPipeline(**__snake_case					)
           snake_case					=       sd_pipe.to(__snake_case					)
           sd_pipe.set_progress_bar_config(disable=__snake_case					)
  
           snake_case					=       self.get_dummy_inputs(__snake_case					)
           snake_case					=       sd_pipe(**__snake_case					).images
           snake_case					=       image[0, -3:, -3:, -1]
           assert image.shape == (1, 6_4, 6_4, 3)
  
           snake_case					=       np.array([0.3573, 0.4420, 0.4960, 0.4799, 0.3796, 0.3879, 0.4819, 0.4365, 0.4468]					)
  
           assert np.abs(image_slice.flatten() - expected_slice					).max() < 1E-2
      def 	a_    ( self					):
           super().test_inference_batch_consistent(batch_sizes=[1, 2]					)
      def 	a_    ( self					):
           super().test_inference_batch_single_identical(batch_size=2    ,      expected_max_diff=3E-3					)
  
  
  
  
      def 	a_    ( self					):
           snake_case					=       '''cpu'''  # ensure determinism for the device-dependent torch.Generator
           snake_case					=       self.get_dummy_components()
           snake_case					=       StableDiffusionParadigmsPipeline(**__snake_case					)
           snake_case					=       sd_pipe.to(__snake_case					)
           sd_pipe.set_progress_bar_config(disable=__snake_case					)
  
           snake_case					=       self.get_dummy_inputs(__snake_case					)
           snake_case					=       '''french fries'''
           snake_case					=       sd_pipe(**__snake_case    ,      negative_prompt=__snake_case					)
           snake_case					=       output.images
           snake_case					=       image[0, -3:, -3:, -1]
  
           assert image.shape == (1, 6_4, 6_4, 3)
  
           snake_case					=       np.array([0.4771, 0.5420, 0.4683, 0.4918, 0.5636, 0.4725, 0.5230, 0.4923, 0.5015]					)
  
           assert np.abs(image_slice.flatten() - expected_slice					).max() < 1E-2
  
  
  
  
  
  
  @slow
  @require_torch_gpu
  class 						A__      (					unittest.TestCase			):
  
  
  
  
  
  
  
      """simple docstring"""
  
      def 	a_    ( self					):
           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()
      def 	a_    ( self    ,      __snake_case=0					):
           snake_case					=       torch.Generator(device=__snake_case					).manual_seed(__snake_case					)
           snake_case					=       {
               '''prompt''': '''a photograph of an astronaut riding a horse''',
               '''generator''': generator,
               '''num_inference_steps''': 1_0,
               '''guidance_scale''': 7.5,
               '''output_type''': '''numpy''',
               '''parallel''': 3,
               '''debug''': True,
           }
           return inputs
  
  
  
  
      def 	a_    ( self					):
           snake_case					=       '''stabilityai/stable-diffusion-2-base'''
           snake_case					=       DDIMParallelScheduler.from_pretrained(__snake_case    ,      subfolder='''scheduler'''					)
           snake_case					=       StableDiffusionParadigmsPipeline.from_pretrained(__snake_case    ,      scheduler=__snake_case    ,      safety_checker=__snake_case					)
           pipe.to(__snake_case					)
           pipe.set_progress_bar_config(disable=__snake_case					)
           pipe.enable_attention_slicing()
  
           snake_case					=       self.get_inputs()
           snake_case					=       pipe(**__snake_case					).images
           snake_case					=       image[0, -3:, -3:, -1].flatten()
  
           assert image.shape == (1, 5_1_2, 5_1_2, 3)
  
           snake_case					=       np.array([0.9622, 0.9602, 0.9748, 0.9591, 0.9630, 0.9691, 0.9661, 0.9631, 0.9741]					)
  
           assert np.abs(expected_slice - image_slice					).max() < 1E-2
  
  
  
  
  