




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					)








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




