


import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers import (
							    OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
							    OpenAIGPTConfig,
							    OpenAIGPTDoubleHeadsModel,
							    OpenAIGPTForSequenceClassification,
							    OpenAIGPTLMHeadModel,
							    OpenAIGPTModel,
							)

class 						A__							:




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


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =parent
										_SCREAMING_SNAKE_CASE			  =batch_size
										_SCREAMING_SNAKE_CASE			  =seq_length
										_SCREAMING_SNAKE_CASE			  =is_training
										_SCREAMING_SNAKE_CASE			  =use_token_type_ids
										_SCREAMING_SNAKE_CASE			  =use_labels
										_SCREAMING_SNAKE_CASE			  =vocab_size
										_SCREAMING_SNAKE_CASE			  =hidden_size
										_SCREAMING_SNAKE_CASE			  =num_hidden_layers
										_SCREAMING_SNAKE_CASE			  =num_attention_heads
										_SCREAMING_SNAKE_CASE			  =intermediate_size
										_SCREAMING_SNAKE_CASE			  =hidden_act
										_SCREAMING_SNAKE_CASE			  =hidden_dropout_prob
										_SCREAMING_SNAKE_CASE			  =attention_probs_dropout_prob
										_SCREAMING_SNAKE_CASE			  =max_position_embeddings
										_SCREAMING_SNAKE_CASE			  =type_vocab_size
										_SCREAMING_SNAKE_CASE			  =type_sequence_label_size
										_SCREAMING_SNAKE_CASE			  =initializer_range
										_SCREAMING_SNAKE_CASE			  =num_labels
										_SCREAMING_SNAKE_CASE			  =num_choices
										_SCREAMING_SNAKE_CASE			  =scope
										_SCREAMING_SNAKE_CASE			  =self.vocab_size - 1




						def 							__UpperCamelCase				(       self					:      List[str]  )							->     List[str]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =ids_tensor([self.batch_size, self.seq_length]				,    self.vocab_size  )

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

										_SCREAMING_SNAKE_CASE			  =None
										_SCREAMING_SNAKE_CASE			  =None
										_SCREAMING_SNAKE_CASE			  =None
										if self.use_labels:
														_SCREAMING_SNAKE_CASE			  =ids_tensor([self.batch_size]				,    self.type_sequence_label_size  )
														_SCREAMING_SNAKE_CASE			  =ids_tensor([self.batch_size, self.seq_length]				,    self.num_labels  )
														_SCREAMING_SNAKE_CASE			  =ids_tensor([self.batch_size]				,    self.num_choices  )

										_SCREAMING_SNAKE_CASE			  =OpenAIGPTConfig(
										    vocab_size=self.vocab_size				,    n_embd=self.hidden_size				,    n_layer=self.num_hidden_layers				,    n_head=self.num_attention_heads				,    n_positions=self.max_position_embeddings				,    pad_token_id=self.pad_token_id				,    )

										_SCREAMING_SNAKE_CASE			  =ids_tensor([self.num_hidden_layers, self.num_attention_heads]				,    2  )

										return (
										    config,
										    input_ids,
										    head_mask,
										    token_type_ids,
										    sequence_labels,
										    token_labels,
										    choice_labels,
										)




						def 							__UpperCamelCase				(       self					:      Optional[int]				,    _a					:      List[str]				,    _a					:      str				,    _a					:      Optional[int]				,    _a					:      int				,    *_a					:      Dict  )							->     List[Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =OpenAIGPTModel(config=_a  )
										model.to(_a  )
										model.eval()

										_SCREAMING_SNAKE_CASE			  =model(_a				,    token_type_ids=_a				,    head_mask=_a  )
										_SCREAMING_SNAKE_CASE			  =model(_a				,    token_type_ids=_a  )
										_SCREAMING_SNAKE_CASE			  =model(_a  )

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




						def 							__UpperCamelCase				(       self					:      Union[str, Any]				,    _a					:      int				,    _a					:      str				,    _a					:      int				,    _a					:      Any				,    *_a					:      Tuple  )							->     str:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =OpenAIGPTLMHeadModel(_a  )
										model.to(_a  )
										model.eval()

										_SCREAMING_SNAKE_CASE			  =model(_a				,    token_type_ids=_a				,    labels=_a  )
										self.parent.assertEqual(result.loss.shape				,    ()  )
										self.parent.assertEqual(result.logits.shape				,    (self.batch_size, self.seq_length, self.vocab_size)  )




						def 							__UpperCamelCase				(       self					:      Union[str, Any]				,    _a					:      Union[str, Any]				,    _a					:      Optional[int]				,    _a					:      Optional[Any]				,    _a					:      Tuple				,    *_a					:      List[str]  )							->     Tuple:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =OpenAIGPTDoubleHeadsModel(_a  )
										model.to(_a  )
										model.eval()

										_SCREAMING_SNAKE_CASE			  =model(_a				,    token_type_ids=_a				,    labels=_a  )
										self.parent.assertEqual(result.loss.shape				,    ()  )
										self.parent.assertEqual(result.logits.shape				,    (self.batch_size, self.seq_length, self.vocab_size)  )




						def 							__UpperCamelCase				(       self					:      Optional[Any]				,    _a					:      Optional[int]				,    _a					:      Any				,    _a					:      Union[str, Any]				,    _a					:      int				,    *_a					:      Optional[Any]  )							->     List[Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.num_labels
										_SCREAMING_SNAKE_CASE			  =OpenAIGPTForSequenceClassification(_a  )
										model.to(_a  )
										model.eval()

										_SCREAMING_SNAKE_CASE			  =ids_tensor([self.batch_size]				,    self.type_sequence_label_size  )
										_SCREAMING_SNAKE_CASE			  =model(_a				,    token_type_ids=_a				,    labels=_a  )
										self.parent.assertEqual(result.logits.shape				,    (self.batch_size, self.num_labels)  )




						def 							__UpperCamelCase				(       self					:      Tuple  )							->     Dict:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.prepare_config_and_inputs()
										(
										    (
										    _SCREAMING_SNAKE_CASE				
										)  ,				(
										    _SCREAMING_SNAKE_CASE				
										)  ,				(
										    _SCREAMING_SNAKE_CASE				
										)  ,				(
										    _SCREAMING_SNAKE_CASE				
										)  ,				(
										    _SCREAMING_SNAKE_CASE				
										)  ,				(
										    _SCREAMING_SNAKE_CASE				
										)  ,				(
										    _SCREAMING_SNAKE_CASE				
										)  ,								
										)			  =config_and_inputs
										_SCREAMING_SNAKE_CASE			  ={
										    '''input_ids''': input_ids,
										    '''token_type_ids''': token_type_ids,
										    '''head_mask''': head_mask,
										}

										return config, inputs_dict

@require_torch
class 						A__							(		UpperCamelCase__   ,     UpperCamelCase__   ,     UpperCamelCase__   ,     unittest.TestCase  ):
						UpperCAmelCase             =						(
						    (OpenAIGPTModel, OpenAIGPTLMHeadModel, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification)
						    if is_torch_available()
						    else ()
						)
						UpperCAmelCase             =						(
						    (OpenAIGPTLMHeadModel,) if is_torch_available() else ()
						)  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
						UpperCAmelCase             =						(
						    {
						        "feature-extraction": OpenAIGPTModel,
						        "text-classification": OpenAIGPTForSequenceClassification,
						        "text-generation": OpenAIGPTLMHeadModel,
						        "zero-shot": OpenAIGPTForSequenceClassification,
						    }
						    if is_torch_available()
						    else {}
						)




						def 							__UpperCamelCase				(       self					:      Tuple				,    _a					:      str				,    _a					:      Optional[Any]				,    _a					:      Dict				,    _a					:      Union[str, Any]				,    _a					:      str  )							->     str:


										"""simple docstring"""





										if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
														# Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
														# `OpenAIGPTConfig` was never used in pipeline tests, either because of a missing checkpoint or because a
														# tiny config could not be created.
														return True

										return False




						def 							__UpperCamelCase				(       self					:      List[Any]				,    _a					:      Optional[Any]				,    _a					:      List[Any]				,    _a					:      Union[str, Any]=False  )							->     Union[str, Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =super()._prepare_for_class(_a				,    _a				,    return_labels=_a  )

										if return_labels:
														if model_class.__name__ == "OpenAIGPTDoubleHeadsModel":
																		_SCREAMING_SNAKE_CASE			  =torch.zeros(
																		    (self.model_tester.batch_size, self.model_tester.num_choices, self.model_tester.seq_length)				,    dtype=torch.long				,    device=_a				,    )
																		_SCREAMING_SNAKE_CASE			  =inputs_dict['''labels''']
																		_SCREAMING_SNAKE_CASE			  =inputs_dict['''labels''']
																		_SCREAMING_SNAKE_CASE			  =torch.zeros(
																		    (self.model_tester.batch_size, self.model_tester.num_choices)				,    dtype=torch.long				,    device=_a				,    )
																		_SCREAMING_SNAKE_CASE			  =torch.zeros(
																		    self.model_tester.batch_size				,    dtype=torch.long				,    device=_a  )
										return inputs_dict




						def 							__UpperCamelCase				(       self					:      List[Any]  )							->     Tuple:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =OpenAIGPTModelTester(self  )
										_SCREAMING_SNAKE_CASE			  =ConfigTester(self				,    config_class=_a				,    n_embd=37  )




						def 							__UpperCamelCase				(       self					:      Optional[Any]  )							->     List[Any]:


										"""simple docstring"""





										self.config_tester.run_common_tests()




						def 							__UpperCamelCase				(       self					:      List[str]  )							->     str:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_openai_gpt_model(*_a  )




						def 							__UpperCamelCase				(       self					:      Any  )							->     List[str]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_lm_head_model(*_a  )




						def 							__UpperCamelCase				(       self					:      Tuple  )							->     int:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_double_lm_head_model(*_a  )




						def 							__UpperCamelCase				(       self					:      List[str]  )							->     Optional[int]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*_a  )




						@slow
						def 							__UpperCamelCase				(       self					:      Any  )							->     int:


										"""simple docstring"""





										for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														_SCREAMING_SNAKE_CASE			  =OpenAIGPTModel.from_pretrained(_a  )
														self.assertIsNotNone(_a  )

@require_torch
class 						A__							(		unittest.TestCase  ):




						@slow
						def 							__UpperCamelCase				(       self					:      int  )							->     Optional[Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =OpenAIGPTLMHeadModel.from_pretrained('''openai-gpt'''  )
										model.to(_a  )
										_SCREAMING_SNAKE_CASE			  =torch.tensor([[481, 4735, 544]]				,    dtype=torch.long				,    device=_a  )  # the president is
										_SCREAMING_SNAKE_CASE			  =[
										    481,
										    4735,
										    544,
										    246,
										    963,
										    870,
										    762,
										    239,
										    244,
										    4_0477,
										    244,
										    249,
										    719,
										    881,
										    487,
										    544,
										    240,
										    244,
										    603,
										    481,
										]  # the president is a very good man. " \n " i\'m sure he is, " said the

										_SCREAMING_SNAKE_CASE			  =model.generate(_a				,    do_sample=_a  )
										self.assertListEqual(output_ids[0].tolist()				,    _a  )



import gc
import random
import unittest

import numpy as np
import torch

from diffusers import DDIMScheduler, KandinskyVaaPipeline, KandinskyVaaPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()

class 						A__							(		UpperCamelCase__   ,     unittest.TestCase  ):
						UpperCAmelCase             =						KandinskyVaaPipeline
						UpperCAmelCase             =						[
						    "image_embeds",
						    "negative_image_embeds",
						]
						UpperCAmelCase             =						["image_embeds", "negative_image_embeds"]
						UpperCAmelCase             =						[
						    "generator",
						    "height",
						    "width",
						    "latents",
						    "guidance_scale",
						    "num_inference_steps",
						    "return_dict",
						    "guidance_scale",
						    "num_images_per_prompt",
						    "output_type",
						    "return_dict",
						]
						UpperCAmelCase             =						False




						@property
						def 							__UpperCamelCase				(       self					:      Tuple  )							->     str:


										"""simple docstring"""





										return 32




						@property
						def 							__UpperCamelCase				(       self					:      Any  )							->     Optional[Any]:


										"""simple docstring"""





										return 32




						@property
						def 							__UpperCamelCase				(       self					:      Optional[int]  )							->     Tuple:


										"""simple docstring"""





										return self.time_input_dim




						@property
						def 							__UpperCamelCase				(       self					:      Optional[int]  )							->     Tuple:


										"""simple docstring"""





										return self.time_input_dim * 4




						@property
						def 							__UpperCamelCase				(       self					:      List[str]  )							->     Dict:


										"""simple docstring"""





										return 100




						@property
						def 							__UpperCamelCase				(       self					:      Optional[int]  )							->     Optional[int]:


										"""simple docstring"""





										torch.manual_seed(0  )

										_SCREAMING_SNAKE_CASE			  ={
										    '''in_channels''': 4,
										    # Out channels is double in channels because predicts mean and variance
										    '''out_channels''': 8,
										    '''addition_embed_type''': '''image''',
										    '''down_block_types''': ('''ResnetDownsampleBlock2D''', '''SimpleCrossAttnDownBlock2D'''),
										    '''up_block_types''': ('''SimpleCrossAttnUpBlock2D''', '''ResnetUpsampleBlock2D'''),
										    '''mid_block_type''': '''UNetMidBlock2DSimpleCrossAttn''',
										    '''block_out_channels''': (self.block_out_channels_a, self.block_out_channels_a * 2),
										    '''layers_per_block''': 1,
										    '''encoder_hid_dim''': self.text_embedder_hidden_size,
										    '''encoder_hid_dim_type''': '''image_proj''',
										    '''cross_attention_dim''': self.cross_attention_dim,
										    '''attention_head_dim''': 4,
										    '''resnet_time_scale_shift''': '''scale_shift''',
										    '''class_embed_type''': None,
										}

										_SCREAMING_SNAKE_CASE			  =UNetaDConditionModel(**_a  )
										return model




						@property
						def 							__UpperCamelCase				(       self					:      Tuple  )							->     Tuple:


										"""simple docstring"""





										return {
										    "block_out_channels": [32, 64],
										    "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
										    "in_channels": 3,
										    "latent_channels": 4,
										    "layers_per_block": 1,
										    "norm_num_groups": 8,
										    "norm_type": "spatial",
										    "num_vq_embeddings": 12,
										    "out_channels": 3,
										    "up_block_types": [
										        "AttnUpDecoderBlock2D",
										        "UpDecoderBlock2D",
										    ],
										    "vq_embed_dim": 4,
										}




						@property
						def 							__UpperCamelCase				(       self					:      Any  )							->     Tuple:


										"""simple docstring"""





										torch.manual_seed(0  )
										_SCREAMING_SNAKE_CASE			  =VQModel(**self.dummy_movq_kwargs  )
										return model




						def 							__UpperCamelCase				(       self					:      Dict  )							->     Optional[Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.dummy_unet
										_SCREAMING_SNAKE_CASE			  =self.dummy_movq

										_SCREAMING_SNAKE_CASE			  =DDIMScheduler(
										    num_train_timesteps=1000				,    beta_schedule='''linear'''				,    beta_start=0.0_00_85				,    beta_end=0.0_12				,    clip_sample=_a				,    set_alpha_to_one=_a				,    steps_offset=1				,    prediction_type='''epsilon'''				,    thresholding=_a				,    )

										_SCREAMING_SNAKE_CASE			  ={
										    '''unet''': unet,
										    '''scheduler''': scheduler,
										    '''movq''': movq,
										}
										return components




						def 							__UpperCamelCase				(       self					:      Optional[int]				,    _a					:      Tuple				,    _a					:      Tuple=0  )							->     Optional[int]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =floats_tensor((1, self.text_embedder_hidden_size)				,    rng=random.Random(_a  )  ).to(_a  )
										_SCREAMING_SNAKE_CASE			  =floats_tensor((1, self.text_embedder_hidden_size)				,    rng=random.Random(seed + 1  )  ).to(
										    _a  )
										if str(_a  ).startswith('''mps'''  ):
														_SCREAMING_SNAKE_CASE			  =torch.manual_seed(_a  )
										else:
														_SCREAMING_SNAKE_CASE			  =torch.Generator(device=_a  ).manual_seed(_a  )
										_SCREAMING_SNAKE_CASE			  ={
										    '''image_embeds''': image_embeds,
										    '''negative_image_embeds''': negative_image_embeds,
										    '''generator''': generator,
										    '''height''': 64,
										    '''width''': 64,
										    '''guidance_scale''': 4.0,
										    '''num_inference_steps''': 2,
										    '''output_type''': '''np''',
										}
										return inputs




						def 							__UpperCamelCase				(       self					:      Optional[Any]  )							->     Union[str, Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  ='''cpu'''

										_SCREAMING_SNAKE_CASE			  =self.get_dummy_components()

										_SCREAMING_SNAKE_CASE			  =self.pipeline_class(**_a  )
										_SCREAMING_SNAKE_CASE			  =pipe.to(_a  )

										pipe.set_progress_bar_config(disable=_a  )

										_SCREAMING_SNAKE_CASE			  =pipe(**self.get_dummy_inputs(_a  )  )
										_SCREAMING_SNAKE_CASE			  =output.images

										_SCREAMING_SNAKE_CASE			  =pipe(
										    **self.get_dummy_inputs(_a  )				,    return_dict=_a				,    )[0]

										_SCREAMING_SNAKE_CASE			  =image[0, -3:, -3:, -1]
										_SCREAMING_SNAKE_CASE			  =image_from_tuple[0, -3:, -3:, -1]

										assert image.shape == (1, 64, 64, 3)

										_SCREAMING_SNAKE_CASE			  =np.array(
										    [0.6_23_79_76, 1.0, 0.36_44_13_32, 1.0, 0.70_63_96_34, 0.29_87_71_86, 0.85_65_21_25, 0.5_21_68_43, 0.54_45_40_46]  )

										assert (
										    np.abs(image_slice.flatten() - expected_slice  ).max() < 1E-2
										), f" expected_slice {expected_slice}, but got {image_slice.flatten()}"

										assert (
										    np.abs(image_from_tuple_slice.flatten() - expected_slice  ).max() < 1E-2
										), f" expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}"

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




						def 							__UpperCamelCase				(       self					:      List[Any]  )							->     Dict:


										"""simple docstring"""





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




						def 							__UpperCamelCase				(       self					:      Union[str, Any]  )							->     str:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =load_numpy(
										    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
										    '''/kandinskyv22/kandinskyv22_text2img_cat_fp16.npy'''  )

										_SCREAMING_SNAKE_CASE			  =KandinskyVaaPriorPipeline.from_pretrained(
										    '''kandinsky-community/kandinsky-2-2-prior'''				,    torch_dtype=torch.floataa  )
										pipe_prior.to(_a  )

										_SCREAMING_SNAKE_CASE			  =KandinskyVaaPipeline.from_pretrained(
										    '''kandinsky-community/kandinsky-2-2-decoder'''				,    torch_dtype=torch.floataa  )
										_SCREAMING_SNAKE_CASE			  =pipeline.to(_a  )
										pipeline.set_progress_bar_config(disable=_a  )

										_SCREAMING_SNAKE_CASE			  ='''red cat, 4k photo'''

										_SCREAMING_SNAKE_CASE			  =torch.Generator(device='''cuda'''  ).manual_seed(0  )
										_SCREAMING_SNAKE_CASE  ,				_SCREAMING_SNAKE_CASE			  =pipe_prior(
										    _a				,    generator=_a				,    num_inference_steps=5				,    negative_prompt=''''''				,    ).to_tuple()

										_SCREAMING_SNAKE_CASE			  =torch.Generator(device='''cuda'''  ).manual_seed(0  )
										_SCREAMING_SNAKE_CASE			  =pipeline(
										    image_embeds=_a				,    negative_image_embeds=_a				,    generator=_a				,    num_inference_steps=100				,    output_type='''np'''				,    )

										_SCREAMING_SNAKE_CASE			  =output.images[0]

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

										assert_mean_pixel_difference(_a				,    _a  )