





"""simple docstring"""






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 					__UpperCAmelCase							:
				def __init__(		self    :			Any	, a_    :			str	, a_    :			Tuple=13	, a_    :			Optional[Any]=7	, a_    :			List[str]=True	, a_    :			List[Any]=True	, a_    :			List[Any]=True	, a_    :			Any=99	, a_    :			List[Any]=32	, a_    :			List[Any]=5	, a_    :			Dict=4	, a_    :			Optional[Any]=37	, a_    :			Optional[Any]="gelu"	, a_    :			List[str]=0.1	, a_    :			Any=0.1	, a_    :			Dict=5_12	, a_    :			Any=16	, a_    :			List[Any]=2	, a_    :			Union[str, Any]=0.02	, a_    :			int=3	, a_    :			List[str]=4	, a_    :			Optional[int]=None	, )	->	Optional[Any]:



							'''simple docstring'''



							a__  :	Optional[int]		 =			parent
							a__  :	int		 =			batch_size
							a__  :	Dict		 =			seq_length
							a__  :	Dict		 =			is_training
							a__  :	List[str]		 =			use_token_type_ids
							a__  :	Optional[Any]		 =			use_labels
							a__  :	Union[str, Any]		 =			vocab_size
							a__  :	Optional[int]		 =			hidden_size
							a__  :	Dict		 =			num_hidden_layers
							a__  :	Optional[int]		 =			num_attention_heads
							a__  :	Optional[Any]		 =			intermediate_size
							a__  :	Any		 =			hidden_act
							a__  :	Union[str, Any]		 =			hidden_dropout_prob
							a__  :	Dict		 =			attention_probs_dropout_prob
							a__  :	Union[str, Any]		 =			max_position_embeddings
							a__  :	Optional[int]		 =			type_vocab_size
							a__  :	int		 =			type_sequence_label_size
							a__  :	Any		 =			initializer_range
							a__  :	int		 =			num_labels
							a__  :	List[Any]		 =			num_choices
							a__  :	str		 =			scope
							a__  :	Any		 =			self.vocab_size - 1
				def       UpperCAmelCase      (		self    :			Tuple    )	->	Optional[Any]:



							'''simple docstring'''



							a__  :	Dict		 =			ids_tensor([self.batch_size, self.seq_length]	, self.vocab_size    )

							a__  :	Tuple		 =			None
							if self.use_token_type_ids:
										a__  :	Optional[int]		 =			ids_tensor([self.batch_size, self.seq_length]	, self.type_vocab_size    )

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

							a__  :	Dict		 =			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	, )

							a__  :	Optional[Any]		 =			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    :			Union[str, Any]	, a_    :			Union[str, Any]	, a_    :			Dict	, a_    :			List[str]	, a_    :			List[str]	, *a_    :			str    )	->	List[str]:



							'''simple docstring'''



							a__  :	List[str]		 =			OpenAIGPTModel(config=a_    )
							model.to(a_    )
							model.eval()

							a__  :	Tuple		 =			model(a_	, token_type_ids=a_	, head_mask=a_    )
							a__  :	Optional[int]		 =			model(a_	, token_type_ids=a_    )
							a__  :	Dict		 =			model(a_    )

							self.parent.assertEqual(result.last_hidden_state.shape	, (self.batch_size, self.seq_length, self.hidden_size)    )
				def       UpperCAmelCase      (		self    :			str	, a_    :			int	, a_    :			Tuple	, a_    :			Union[str, Any]	, a_    :			Any	, *a_    :			Dict    )	->	List[str]:



							'''simple docstring'''



							a__  :	int		 =			OpenAIGPTLMHeadModel(a_    )
							model.to(a_    )
							model.eval()

							a__  :	Union[str, Any]		 =			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    :			str	, a_    :			List[str]	, a_    :			int	, a_    :			int	, a_    :			int	, *a_    :			Optional[Any]    )	->	Union[str, Any]:



							'''simple docstring'''



							a__  :	Any		 =			OpenAIGPTDoubleHeadsModel(a_    )
							model.to(a_    )
							model.eval()

							a__  :	int		 =			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    :			int	, a_    :			Tuple	, a_    :			Union[str, Any]	, a_    :			int	, a_    :			List[Any]	, *a_    :			Optional[Any]    )	->	Optional[Any]:



							'''simple docstring'''



							a__  :	Union[str, Any]		 =			self.num_labels
							a__  :	Any		 =			OpenAIGPTForSequenceClassification(a_    )
							model.to(a_    )
							model.eval()

							a__  :	Optional[int]		 =			ids_tensor([self.batch_size]	, self.type_sequence_label_size    )
							a__  :	str		 =			model(a_	, token_type_ids=a_	, labels=a_    )
							self.parent.assertEqual(result.logits.shape	, (self.batch_size, self.num_labels)    )






				def       UpperCAmelCase      (		self    :			int    )	->	Dict:



							'''simple docstring'''



							a__  :	List[Any]		 =			self.prepare_config_and_inputs()
							(
							    (
							    a__
							) ,	(
							    a__
							) ,	(
							    a__
							) ,	(
							    a__
							) ,	(
							    a__
							) ,	(
							    a__
							) ,	(
							    a__
							) ,	
							)  :	Optional[Any]		 =			config_and_inputs
							a__  :	Any		 =			{
							    "input_ids": input_ids,
							    "token_type_ids": token_type_ids,
							    "head_mask": head_mask,
							}

							return config, inputs_dict



@require_torch
class 					__UpperCAmelCase							(						_UpperCamelCase						,  _UpperCamelCase						,  _UpperCamelCase						,  unittest.TestCase  ):
				__lowerCamelCase				:	Any				     =				(
				    (OpenAIGPTModel, OpenAIGPTLMHeadModel, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification)
				    if is_torch_available()
				    else ()
				)
				__lowerCamelCase				:	int				     =				(
				    (OpenAIGPTLMHeadModel,) if is_torch_available() else ()
				)  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
				__lowerCamelCase				:	Optional[Any]				     =				(
				    {
				        "feature-extraction": OpenAIGPTModel,
				        "text-classification": OpenAIGPTForSequenceClassification,
				        "text-generation": OpenAIGPTLMHeadModel,
				        "zero-shot": OpenAIGPTForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)
				def       UpperCAmelCase      (		self    :			Any	, a_    :			int	, a_    :			List[str]	, a_    :			Optional[Any]	, a_    :			Union[str, Any]	, a_    :			int    )	->	List[Any]:



							'''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    :			Tuple	, a_    :			Any	, a_    :			str	, a_    :			Optional[Any]=False    )	->	Any:



							'''simple docstring'''



							a__  :	int		 =			super()._prepare_for_class(a_	, a_	, return_labels=a_    )

							if return_labels:
										if model_class.__name__ == "OpenAIGPTDoubleHeadsModel":
													a__  :	Dict		 =			torch.zeros(
													    (self.model_tester.batch_size, self.model_tester.num_choices, self.model_tester.seq_length)	, dtype=torch.long	, device=a_	, )
													a__  :	Tuple		 =			inputs_dict["labels"]
													a__  :	List[str]		 =			inputs_dict["labels"]
													a__  :	Dict		 =			torch.zeros(
													    (self.model_tester.batch_size, self.model_tester.num_choices)	, dtype=torch.long	, device=a_	, )
													a__  :	Optional[Any]		 =			torch.zeros(
													    self.model_tester.batch_size	, dtype=torch.long	, device=a_    )
							return inputs_dict
				def       UpperCAmelCase      (		self    :			Any    )	->	List[str]:



							'''simple docstring'''



							a__  :	Optional[Any]		 =			OpenAIGPTModelTester(self    )
							a__  :	int		 =			ConfigTester(self	, config_class=a_	, n_embd=37    )
				def       UpperCAmelCase      (		self    :			Optional[int]    )	->	Optional[Any]:



							'''simple docstring'''



							self.config_tester.run_common_tests()
				def       UpperCAmelCase      (		self    :			str    )	->	Tuple:



							'''simple docstring'''



							a__  :	Tuple		 =			self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_openai_gpt_model(*a_    )
				def       UpperCAmelCase      (		self    :			Optional[Any]    )	->	Optional[Any]:



							'''simple docstring'''



							a__  :	Dict		 =			self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_lm_head_model(*a_    )
				def       UpperCAmelCase      (		self    :			Tuple    )	->	Any:



							'''simple docstring'''



							a__  :	Dict		 =			self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_double_lm_head_model(*a_    )
				def       UpperCAmelCase      (		self    :			Union[str, Any]    )	->	Any:



							'''simple docstring'''



							a__  :	str		 =			self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*a_    )






				@slow
				def       UpperCAmelCase      (		self    :			Dict    )	->	Tuple:



							'''simple docstring'''



							for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										a__  :	Any		 =			OpenAIGPTModel.from_pretrained(a_    )
										self.assertIsNotNone(a_    )



@require_torch
class 					__UpperCAmelCase							(						unittest.TestCase  ):
				@slow
				def       UpperCAmelCase      (		self    :			Optional[int]    )	->	Optional[Any]:



							'''simple docstring'''



							a__  :	List[str]		 =			OpenAIGPTLMHeadModel.from_pretrained("openai-gpt"    )
							model.to(a_    )
							a__  :	Dict		 =			torch.tensor([[4_81, 47_35, 5_44]]	, dtype=torch.long	, device=a_    )  # the president is
							a__  :	int		 =			[
							    4_81,
							    47_35,
							    5_44,
							    2_46,
							    9_63,
							    8_70,
							    7_62,
							    2_39,
							    2_44,
							    4_04_77,
							    2_44,
							    2_49,
							    7_19,
							    8_81,
							    4_87,
							    5_44,
							    2_40,
							    2_44,
							    6_03,
							    4_81,
							]  # the president is a very good man. " \n " i\'m sure he is, " said the

							a__  :	List[str]		 =			model.generate(a_	, do_sample=a_    )
							self.assertListEqual(output_ids[0].tolist()	, a_    )






"""simple docstring"""






import tempfile

import numpy as np
import torch
from transformers import AutoTokenizer, TaEncoderModel

from diffusers import DDPMScheduler, UNetaDConditionModel
from diffusers.models.attention_processor import AttnAddedKVProcessor
from diffusers.pipelines.deepfloyd_if import IFWatermarker
from diffusers.utils.testing_utils import torch_device

from ..test_pipelines_common import to_np



class 					__UpperCAmelCase							:
				def       UpperCAmelCase      (		self    :			List[str]    )	->	List[str]:



							'''simple docstring'''



							torch.manual_seed(0    )
							a__  :	List[str]		 =			TaEncoderModel.from_pretrained("hf-internal-testing/tiny-random-t5"    )

							torch.manual_seed(0    )
							a__  :	int		 =			AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-t5"    )

							torch.manual_seed(0    )
							a__  :	Any		 =			UNetaDConditionModel(
							    sample_size=32	, layers_per_block=1	, block_out_channels=[32, 64]	, down_block_types=[
							        "ResnetDownsampleBlock2D",
							        "SimpleCrossAttnDownBlock2D",
							    ]	, mid_block_type="UNetMidBlock2DSimpleCrossAttn"	, up_block_types=["SimpleCrossAttnUpBlock2D", "ResnetUpsampleBlock2D"]	, in_channels=3	, out_channels=6	, cross_attention_dim=32	, encoder_hid_dim=32	, attention_head_dim=8	, addition_embed_type="text"	, addition_embed_type_num_heads=2	, cross_attention_norm="group_norm"	, resnet_time_scale_shift="scale_shift"	, act_fn="gelu"	, )
							unet.set_attn_processor(AttnAddedKVProcessor()    )  # For reproducibility tests

							torch.manual_seed(0    )
							a__  :	str		 =			DDPMScheduler(
							    num_train_timesteps=10_00	, beta_schedule="squaredcos_cap_v2"	, beta_start=0.0001	, beta_end=0.02	, thresholding=a_	, dynamic_thresholding_ratio=0.95	, sample_max_value=1.0	, prediction_type="epsilon"	, variance_type="learned_range"	, )

							torch.manual_seed(0    )
							a__  :	Optional[int]		 =			IFWatermarker()

							return {
							    "text_encoder": text_encoder,
							    "tokenizer": tokenizer,
							    "unet": unet,
							    "scheduler": scheduler,
							    "watermarker": watermarker,
							    "safety_checker": None,
							    "feature_extractor": None,
							}
				def       UpperCAmelCase      (		self    :			Optional[Any]    )	->	Union[str, Any]:



							'''simple docstring'''



							torch.manual_seed(0    )
							a__  :	List[Any]		 =			TaEncoderModel.from_pretrained("hf-internal-testing/tiny-random-t5"    )

							torch.manual_seed(0    )
							a__  :	List[str]		 =			AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-t5"    )

							torch.manual_seed(0    )
							a__  :	Dict		 =			UNetaDConditionModel(
							    sample_size=32	, layers_per_block=[1, 2]	, block_out_channels=[32, 64]	, down_block_types=[
							        "ResnetDownsampleBlock2D",
							        "SimpleCrossAttnDownBlock2D",
							    ]	, mid_block_type="UNetMidBlock2DSimpleCrossAttn"	, up_block_types=["SimpleCrossAttnUpBlock2D", "ResnetUpsampleBlock2D"]	, in_channels=6	, out_channels=6	, cross_attention_dim=32	, encoder_hid_dim=32	, attention_head_dim=8	, addition_embed_type="text"	, addition_embed_type_num_heads=2	, cross_attention_norm="group_norm"	, resnet_time_scale_shift="scale_shift"	, act_fn="gelu"	, class_embed_type="timestep"	, mid_block_scale_factor=1.414	, time_embedding_act_fn="gelu"	, time_embedding_dim=32	, )
							unet.set_attn_processor(AttnAddedKVProcessor()    )  # For reproducibility tests

							torch.manual_seed(0    )
							a__  :	Optional[int]		 =			DDPMScheduler(
							    num_train_timesteps=10_00	, beta_schedule="squaredcos_cap_v2"	, beta_start=0.0001	, beta_end=0.02	, thresholding=a_	, dynamic_thresholding_ratio=0.95	, sample_max_value=1.0	, prediction_type="epsilon"	, variance_type="learned_range"	, )

							torch.manual_seed(0    )
							a__  :	Tuple		 =			DDPMScheduler(
							    num_train_timesteps=10_00	, beta_schedule="squaredcos_cap_v2"	, beta_start=0.0001	, beta_end=0.02	, )

							torch.manual_seed(0    )
							a__  :	Optional[Any]		 =			IFWatermarker()

							return {
							    "text_encoder": text_encoder,
							    "tokenizer": tokenizer,
							    "unet": unet,
							    "scheduler": scheduler,
							    "image_noising_scheduler": image_noising_scheduler,
							    "watermarker": watermarker,
							    "safety_checker": None,
							    "feature_extractor": None,
							}
				def       UpperCAmelCase      (		self    :			List[Any]    )	->	Tuple:



							'''simple docstring'''



							a__  :	Dict		 =			self.get_dummy_components()
							a__  :	Any		 =			self.pipeline_class(**a_    )
							pipe.to(a_    )
							pipe.set_progress_bar_config(disable=a_    )

							a__  :	Any		 =			self.get_dummy_inputs(a_    )

							a__  :	Optional[int]		 =			inputs["prompt"]
							a__  :	List[Any]		 =			inputs["generator"]
							a__  :	Optional[int]		 =			inputs["num_inference_steps"]
							a__  :	Any		 =			inputs["output_type"]

							if "image" in inputs:
										a__  :	Any		 =			inputs["image"]
							else:
										a__  :	Dict		 =			None

							if "mask_image" in inputs:
										a__  :	Optional[int]		 =			inputs["mask_image"]
							else:
										a__  :	Any		 =			None

							if "original_image" in inputs:
										a__  :	List[Any]		 =			inputs["original_image"]
							else:
										a__  :	str		 =			None

							a__ ,	a__  :	Optional[int]		 =			pipe.encode_prompt(a_    )

							# inputs with prompt converted to embeddings
							a__  :	Union[str, Any]		 =			{
							    "prompt_embeds": prompt_embeds,
							    "negative_prompt_embeds": negative_prompt_embeds,
							    "generator": generator,
							    "num_inference_steps": num_inference_steps,
							    "output_type": output_type,
							}

							if image is not None:
										a__  :	Dict		 =			image

							if mask_image is not None:
										a__  :	Any		 =			mask_image

							if original_image is not None:
										a__  :	Optional[int]		 =			original_image

							# set all optional components to None
							for optional_component in pipe._optional_components:
										setattr(a_	, a_	, a_    )

							a__  :	int		 =			pipe(**a_    )[0]

							with tempfile.TemporaryDirectory() as tmpdir:
										pipe.save_pretrained(a_    )
										a__  :	List[str]		 =			self.pipeline_class.from_pretrained(a_    )
										pipe_loaded.to(a_    )
										pipe_loaded.set_progress_bar_config(disable=a_    )

							pipe_loaded.unet.set_attn_processor(AttnAddedKVProcessor()    )  # For reproducibility tests

							for optional_component in pipe._optional_components:
										self.assertTrue(
										    getattr(a_	, a_    ) is None	, F"`{optional_component}` did not stay set to None after loading."	, )

							a__  :	Union[str, Any]		 =			self.get_dummy_inputs(a_    )

							a__  :	str		 =			inputs["generator"]
							a__  :	Dict		 =			inputs["num_inference_steps"]
							a__  :	Optional[int]		 =			inputs["output_type"]

							# inputs with prompt converted to embeddings
							a__  :	List[Any]		 =			{
							    "prompt_embeds": prompt_embeds,
							    "negative_prompt_embeds": negative_prompt_embeds,
							    "generator": generator,
							    "num_inference_steps": num_inference_steps,
							    "output_type": output_type,
							}

							if image is not None:
										a__  :	Dict		 =			image

							if mask_image is not None:
										a__  :	Any		 =			mask_image

							if original_image is not None:
										a__  :	Dict		 =			original_image

							a__  :	Optional[Any]		 =			pipe_loaded(**a_    )[0]

							a__  :	int		 =			np.abs(to_np(a_    ) - to_np(a_    )    ).max()
							self.assertLess(a_	, 1E-4    )






				def       UpperCAmelCase      (		self    :			int    )	->	Any:



							'''simple docstring'''



							a__  :	Dict		 =			self.get_dummy_components()
							a__  :	Dict		 =			self.pipeline_class(**a_    )
							pipe.to(a_    )
							pipe.set_progress_bar_config(disable=a_    )

							a__  :	List[str]		 =			self.get_dummy_inputs(a_    )
							a__  :	Dict		 =			pipe(**a_    )[0]

							with tempfile.TemporaryDirectory() as tmpdir:
										pipe.save_pretrained(a_    )
										a__  :	str		 =			self.pipeline_class.from_pretrained(a_    )
										pipe_loaded.to(a_    )
										pipe_loaded.set_progress_bar_config(disable=a_    )

							pipe_loaded.unet.set_attn_processor(AttnAddedKVProcessor()    )  # For reproducibility tests

							a__  :	Optional[int]		 =			self.get_dummy_inputs(a_    )
							a__  :	Optional[int]		 =			pipe_loaded(**a_    )[0]

							a__  :	List[Any]		 =			np.abs(to_np(a_    ) - to_np(a_    )    ).max()
							self.assertLess(a_	, 1E-4    )