


"""simple docstring"""
from __future__ import annotations

import unittest

from transformers import DistilBertConfig, 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.models.distilbert.modeling_tf_distilbert import (
     TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
     TFDistilBertForMaskedLM,
     TFDistilBertForMultipleChoice,
     TFDistilBertForQuestionAnswering,
     TFDistilBertForSequenceClassification,
     TFDistilBertForTokenClassification,
     TFDistilBertModel,
 )




class 	lowercase__				:





   def __init__(							self      ,   SCREAMING_SNAKE_CASE      ,   )  ->  Dict:
      _lowerCamelCase	:					int   =		parent
      _lowerCamelCase	:					Union[str, Any]   =		13
      _lowerCamelCase	:					List[str]   =		7
      _lowerCamelCase	:					Optional[int]   =		True
      _lowerCamelCase	:					Dict   =		True
      _lowerCamelCase	:					Any   =		False
      _lowerCamelCase	:					List[Any]   =		True
      _lowerCamelCase	:					Tuple   =		99
      _lowerCamelCase	:					Optional[Any]   =		32
      _lowerCamelCase	:					int   =		2
      _lowerCamelCase	:					Dict   =		4
      _lowerCamelCase	:					List[Any]   =		37
      _lowerCamelCase	:					Optional[int]   =		"""gelu"""
      _lowerCamelCase	:					str   =		0.1
      _lowerCamelCase	:					Optional[Any]   =		0.1
      _lowerCamelCase	:					int   =		512
      _lowerCamelCase	:					Optional[Any]   =		16
      _lowerCamelCase	:					Tuple   =		2
      _lowerCamelCase	:					str   =		0.02
      _lowerCamelCase	:					int   =		3
      _lowerCamelCase	:					Optional[int]   =		4
      _lowerCamelCase	:					Union[str, Any]   =		None





   def 		UpperCamelCase_  (							self)  ->  Optional[Any]:
      _lowerCamelCase	:					List[str]   =		ids_tensor([self.batch_size, self.seq_length]      ,   self.vocab_size)

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

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

      _lowerCamelCase	:					Optional[int]   =		DistilBertConfig(
          vocab_size=self.vocab_size      ,   dim=self.hidden_size      ,   n_layers=self.num_hidden_layers      ,   n_heads=self.num_attention_heads      ,   hidden_dim=self.intermediate_size      ,   hidden_act=self.hidden_act      ,   dropout=self.hidden_dropout_prob      ,   attention_dropout=self.attention_probs_dropout_prob      ,   max_position_embeddings=self.max_position_embeddings      ,   initializer_range=self.initializer_range      ,   )

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





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE)  ->  List[str]:
      _lowerCamelCase	:					List[Any]   =		TFDistilBertModel(config=SCREAMING_SNAKE_CASE)
      _lowerCamelCase	:					List[Any]   =		{"""input_ids""": input_ids, """attention_mask""": input_mask}

      _lowerCamelCase	:					Any   =		model(SCREAMING_SNAKE_CASE)

      _lowerCamelCase	:					int   =		[input_ids, input_mask]

      _lowerCamelCase	:					int   =		model(SCREAMING_SNAKE_CASE)

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





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE)  ->  List[Any]:
      _lowerCamelCase	:					List[str]   =		TFDistilBertForMaskedLM(config=SCREAMING_SNAKE_CASE)
      _lowerCamelCase	:					Union[str, Any]   =		{"""input_ids""": input_ids, """attention_mask""": input_mask}
      _lowerCamelCase	:					Optional[int]   =		model(SCREAMING_SNAKE_CASE)
      self.parent.assertEqual(result.logits.shape      ,   (self.batch_size, self.seq_length, self.vocab_size))





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE)  ->  int:
      _lowerCamelCase	:					str   =		TFDistilBertForQuestionAnswering(config=SCREAMING_SNAKE_CASE)
      _lowerCamelCase	:					Union[str, Any]   =		{
          """input_ids""": input_ids,
          """attention_mask""": input_mask,
      }
      _lowerCamelCase	:					Optional[Any]   =		model(SCREAMING_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      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE)  ->  Optional[int]:
      _lowerCamelCase	:					Optional[Any]   =		self.num_labels
      _lowerCamelCase	:					Any   =		TFDistilBertForSequenceClassification(SCREAMING_SNAKE_CASE)
      _lowerCamelCase	:					str   =		{"""input_ids""": input_ids, """attention_mask""": input_mask}
      _lowerCamelCase	:					Dict   =		model(SCREAMING_SNAKE_CASE)
      self.parent.assertEqual(result.logits.shape      ,   (self.batch_size, self.num_labels))





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE)  ->  str:
      _lowerCamelCase	:					Dict   =		self.num_choices
      _lowerCamelCase	:					int   =		TFDistilBertForMultipleChoice(SCREAMING_SNAKE_CASE)
      _lowerCamelCase	:					List[str]   =		tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE      ,   1)      ,   (1, self.num_choices, 1))
      _lowerCamelCase	:					List[str]   =		tf.tile(tf.expand_dims(SCREAMING_SNAKE_CASE      ,   1)      ,   (1, self.num_choices, 1))
      _lowerCamelCase	:					Tuple   =		{
          """input_ids""": multiple_choice_inputs_ids,
          """attention_mask""": multiple_choice_input_mask,
      }
      _lowerCamelCase	:					Any   =		model(SCREAMING_SNAKE_CASE)
      self.parent.assertEqual(result.logits.shape      ,   (self.batch_size, self.num_choices))





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE)  ->  int:
      _lowerCamelCase	:					str   =		self.num_labels
      _lowerCamelCase	:					int   =		TFDistilBertForTokenClassification(SCREAMING_SNAKE_CASE)
      _lowerCamelCase	:					Any   =		{"""input_ids""": input_ids, """attention_mask""": input_mask}
      _lowerCamelCase	:					Tuple   =		model(SCREAMING_SNAKE_CASE)
      self.parent.assertEqual(result.logits.shape      ,   (self.batch_size, self.seq_length, self.num_labels))





   def 		UpperCamelCase_  (							self)  ->  List[str]:
      _lowerCamelCase	:					int   =		self.prepare_config_and_inputs()
      ((_lowerCamelCase)   ,    (_lowerCamelCase)   ,    (_lowerCamelCase)   ,    (_lowerCamelCase)   ,    (_lowerCamelCase)   ,    (_lowerCamelCase))	:					List[str]   =		config_and_inputs
      _lowerCamelCase	:					Optional[Any]   =		{"""input_ids""": input_ids, """attention_mask""": input_mask}
      return config, inputs_dict







@require_tf
class 	lowercase__				(					A_ ,A_ ,unittest.TestCase				):
   __UpperCAmelCase							       =					(
       (
           TFDistilBertModel,
           TFDistilBertForMaskedLM,
           TFDistilBertForQuestionAnswering,
           TFDistilBertForSequenceClassification,
           TFDistilBertForTokenClassification,
           TFDistilBertForMultipleChoice,
       )
       if is_tf_available()
       else None
   )
   __UpperCAmelCase							       =					(
       {
           '''feature-extraction''': TFDistilBertModel,
           '''fill-mask''': TFDistilBertForMaskedLM,
           '''question-answering''': TFDistilBertForQuestionAnswering,
           '''text-classification''': TFDistilBertForSequenceClassification,
           '''token-classification''': TFDistilBertForTokenClassification,
           '''zero-shot''': TFDistilBertForSequenceClassification,
       }
       if is_tf_available()
       else {}
   )
   __UpperCAmelCase							       =					False
   __UpperCAmelCase							       =					False





   def 		UpperCamelCase_  (							self)  ->  List[str]:
      _lowerCamelCase	:					str   =		TFDistilBertModelTester(self)
      _lowerCamelCase	:					Any   =		ConfigTester(self      ,   config_class=SCREAMING_SNAKE_CASE      ,   dim=37)





   def 		UpperCamelCase_  (							self)  ->  List[Any]:
      self.config_tester.run_common_tests()





   def 		UpperCamelCase_  (							self)  ->  str:
      _lowerCamelCase	:					Dict   =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_distilbert_model(*SCREAMING_SNAKE_CASE)





   def 		UpperCamelCase_  (							self)  ->  str:
      _lowerCamelCase	:					Union[str, Any]   =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_distilbert_for_masked_lm(*SCREAMING_SNAKE_CASE)





   def 		UpperCamelCase_  (							self)  ->  Dict:
      _lowerCamelCase	:					Dict   =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_distilbert_for_question_answering(*SCREAMING_SNAKE_CASE)





   def 		UpperCamelCase_  (							self)  ->  int:
      _lowerCamelCase	:					Dict   =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_distilbert_for_sequence_classification(*SCREAMING_SNAKE_CASE)





   def 		UpperCamelCase_  (							self)  ->  Dict:
      _lowerCamelCase	:					Any   =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_distilbert_for_multiple_choice(*SCREAMING_SNAKE_CASE)





   def 		UpperCamelCase_  (							self)  ->  List[Any]:
      _lowerCamelCase	:					Dict   =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_distilbert_for_token_classification(*SCREAMING_SNAKE_CASE)





   @slow
   def 		UpperCamelCase_  (							self)  ->  List[str]:
      for model_name in list(TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]):
         _lowerCamelCase	:					Tuple   =		TFDistilBertModel.from_pretrained(SCREAMING_SNAKE_CASE)
         self.assertIsNotNone(SCREAMING_SNAKE_CASE)







@require_tf
class 	lowercase__				(					unittest.TestCase				):





   @slow
   def 		UpperCamelCase_  (							self)  ->  List[Any]:
      _lowerCamelCase	:					Union[str, Any]   =		TFDistilBertModel.from_pretrained("""distilbert-base-uncased""")
      _lowerCamelCase	:					Optional[int]   =		tf.constant([[0, 1, 2, 3, 4, 5]])
      _lowerCamelCase	:					List[Any]   =		model(SCREAMING_SNAKE_CASE)[0]

      _lowerCamelCase	:					str   =		[1, 6, 768]
      self.assertEqual(output.shape      ,   SCREAMING_SNAKE_CASE)

      _lowerCamelCase	:					List[str]   =		tf.constant(
          [
              [
                  [0.19_26_18_85, -0.13_73_29_55, 0.4_11_97_99],
                  [0.22_15_01_56, -0.07_42_26_61, 0.39_03_72_04],
                  [0.22_75_60_18, -0.0_89_64_14, 0.3_70_14_67],
              ]
          ])
      tf.debugging.assert_near(output[:, :3, :3]      ,   SCREAMING_SNAKE_CASE      ,   atol=1e-4)


import gc
import unittest

import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DDPMScheduler,
    PriorTransformer,
    StableUnCLIPPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.testing_utils import enable_full_determinism, load_numpy, require_torch_gpu, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()
class     lowerCAmelCase_     (       __lowercase,  __lowercase,  __lowercase,  unittest.TestCase ):
							UpperCAmelCase				   =     StableUnCLIPPipeline
							UpperCAmelCase				   =     TEXT_TO_IMAGE_PARAMS
							UpperCAmelCase				   =     TEXT_TO_IMAGE_BATCH_PARAMS
							UpperCAmelCase				   =     TEXT_TO_IMAGE_IMAGE_PARAMS
							UpperCAmelCase				   =     TEXT_TO_IMAGE_IMAGE_PARAMS

							# TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
							UpperCAmelCase				   =     False







							def  UpperCamelCase_						(   self      :     Optional[int]		):
												_UpperCamelCase			     =     32
												_UpperCamelCase			     =     embedder_hidden_size

												# prior components

												torch.manual_seed(0		)
												_UpperCamelCase			     =     CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''		)

												torch.manual_seed(0		)
												_UpperCamelCase			     =     CLIPTextModelWithProjection(
												    CLIPTextConfig(
												        bos_token_id=0 ,			eos_token_id=2 ,			hidden_size=_A ,			projection_dim=_A ,			intermediate_size=37 ,			layer_norm_eps=1e-05 ,			num_attention_heads=4 ,			num_hidden_layers=5 ,			pad_token_id=1 ,			vocab_size=1000 ,			)		)

												torch.manual_seed(0		)
												_UpperCamelCase			     =     PriorTransformer(
												    num_attention_heads=2 ,			attention_head_dim=12 ,			embedding_dim=_A ,			num_layers=1 ,			)

												torch.manual_seed(0		)
												_UpperCamelCase			     =     DDPMScheduler(
												    variance_type='''fixed_small_log''' ,			prediction_type='''sample''' ,			num_train_timesteps=1000 ,			clip_sample=_A ,			clip_sample_range=5.0 ,			beta_schedule='''squaredcos_cap_v2''' ,			)

												# regular denoising components

												torch.manual_seed(0		)
												_UpperCamelCase			     =     StableUnCLIPImageNormalizer(embedding_dim=_A		)
												_UpperCamelCase			     =     DDPMScheduler(beta_schedule='''squaredcos_cap_v2'''		)

												torch.manual_seed(0		)
												_UpperCamelCase			     =     CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''		)

												torch.manual_seed(0		)
												_UpperCamelCase			     =     CLIPTextModel(
												    CLIPTextConfig(
												        bos_token_id=0 ,			eos_token_id=2 ,			hidden_size=_A ,			projection_dim=32 ,			intermediate_size=37 ,			layer_norm_eps=1e-05 ,			num_attention_heads=4 ,			num_hidden_layers=5 ,			pad_token_id=1 ,			vocab_size=1000 ,			)		)

												torch.manual_seed(0		)
												_UpperCamelCase			     =     UNetaDConditionModel(
												    sample_size=32 ,			in_channels=4 ,			out_channels=4 ,			down_block_types=('''CrossAttnDownBlock2D''', '''DownBlock2D''') ,			up_block_types=('''UpBlock2D''', '''CrossAttnUpBlock2D''') ,			block_out_channels=(32, 64) ,			attention_head_dim=(2, 4) ,			class_embed_type='''projection''' ,			projection_class_embeddings_input_dim=embedder_projection_dim * 2 ,			cross_attention_dim=_A ,			layers_per_block=1 ,			upcast_attention=_A ,			use_linear_projection=_A ,			)

												torch.manual_seed(0		)
												_UpperCamelCase			     =     DDIMScheduler(
												    beta_schedule='''scaled_linear''' ,			beta_start=0.0_0085 ,			beta_end=0.012 ,			prediction_type='''v_prediction''' ,			set_alpha_to_one=_A ,			steps_offset=1 ,			)

												torch.manual_seed(0		)
												_UpperCamelCase			     =     AutoencoderKL()

												_UpperCamelCase			     =     {
												    # prior components
												    '''prior_tokenizer''': prior_tokenizer,
												    '''prior_text_encoder''': prior_text_encoder,
												    '''prior''': prior,
												    '''prior_scheduler''': prior_scheduler,
												    # image noising components
												    '''image_normalizer''': image_normalizer,
												    '''image_noising_scheduler''': image_noising_scheduler,
												    # regular denoising components
												    '''tokenizer''': tokenizer,
												    '''text_encoder''': text_encoder,
												    '''unet''': unet,
												    '''scheduler''': scheduler,
												    '''vae''': vae,
												}

												return components







							def  UpperCamelCase_						(   self      :     Dict ,			_A      :     Tuple ,			_A      :     Dict=0		):
												if str(_A		).startswith('''mps'''		):
																	_UpperCamelCase			     =     torch.manual_seed(_A		)
												else:
																	_UpperCamelCase			     =     torch.Generator(device=_A		).manual_seed(_A		)
												_UpperCamelCase			     =     {
												    '''prompt''': '''A painting of a squirrel eating a burger''',
												    '''generator''': generator,
												    '''num_inference_steps''': 2,
												    '''prior_num_inference_steps''': 2,
												    '''output_type''': '''numpy''',
												}
												return inputs







							def  UpperCamelCase_						(   self      :     Dict		):
												_UpperCamelCase			     =     torch_device == '''cpu'''

												self._test_attention_slicing_forward_pass(test_max_difference=_A		)







							def  UpperCamelCase_						(   self      :     List[Any]		):
												_UpperCamelCase			     =     torch_device in ['''cpu''', '''mps''']

												self._test_inference_batch_single_identical(test_max_difference=_A		)




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







							def  UpperCamelCase_						(   self      :     Optional[Any]		):
												# clean up the VRAM after each test
												super().tearDown()
												gc.collect()
												torch.cuda.empty_cache()







							def  UpperCamelCase_						(   self      :     List[str]		):
												_UpperCamelCase			     =     load_numpy(
												    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy'''		)

												_UpperCamelCase			     =     StableUnCLIPPipeline.from_pretrained('''fusing/stable-unclip-2-1-l''' ,			torch_dtype=torch.floataa		)
												pipe.to(_A		)
												pipe.set_progress_bar_config(disable=_A		)
												# stable unclip will oom when integration tests are run on a V100,
												# so turn on memory savings
												pipe.enable_attention_slicing()
												pipe.enable_sequential_cpu_offload()

												_UpperCamelCase			     =     torch.Generator(device='''cpu'''		).manual_seed(0		)
												_UpperCamelCase			     =     pipe('''anime turle''' ,			generator=_A ,			output_type='''np'''		)

												_UpperCamelCase			     =     output.images[0]

												assert image.shape == (768, 768, 3)

												assert_mean_pixel_difference(_A ,			_A		)







							def  UpperCamelCase_						(   self      :     Optional[Any]		):
												torch.cuda.empty_cache()
												torch.cuda.reset_max_memory_allocated()
												torch.cuda.reset_peak_memory_stats()

												_UpperCamelCase			     =     StableUnCLIPPipeline.from_pretrained('''fusing/stable-unclip-2-1-l''' ,			torch_dtype=torch.floataa		)
												_UpperCamelCase			     =     pipe.to(_A		)
												pipe.set_progress_bar_config(disable=_A		)
												pipe.enable_attention_slicing()
												pipe.enable_sequential_cpu_offload()

												_UpperCamelCase			     =     pipe(
												    '''anime turtle''' ,			prior_num_inference_steps=2 ,			num_inference_steps=2 ,			output_type='''np''' ,			)

												_UpperCamelCase			     =     torch.cuda.max_memory_allocated()
												# make sure that less than 7 GB is allocated
												assert mem_bytes < 7 * 10**9
