code: 
  
  
  
  """simple docstring"""
  
  
  
  
  from logging import getLogger
  from typing import Any, Callable, List, Optional, Union
  
  import numpy as np
  import PIL
  import torch
  
  from ...schedulers import DDPMScheduler
  from ..onnx_utils import ORT_TO_NP_TYPE, OnnxRuntimeModel
  from ..pipeline_utils import ImagePipelineOutput
  from . import StableDiffusionUpscalePipeline
  
  
  _lowerCAmelCase       :      int							=							getLogger(__name__)
  
  
  _lowerCAmelCase       :      Union[str, Any]							=							4
  _lowerCAmelCase       :      str							=							7
  
  _lowerCAmelCase       :      Optional[Any]							=							{
      'float16': torch.floataa,
      'float32': torch.floataa,
  }
  
  def 		__snake_case		(   SCREAMING_SNAKE_CASE__			:		List[str]       )						->     Optional[int]:
  
  
  
  
  
  					'''simple docstring'''
  
  					if isinstance(__A		,						torch.Tensor       ):
  										return image
  					elif isinstance(__A		,						PIL.Image.Image       ):
  										_UpperCAmelCase    :			Dict              =					[image]
  
  					if isinstance(image[0]		,						PIL.Image.Image       ):
  										_UpperCAmelCase       , _UpperCAmelCase    :			Any              =					image[0].size
  										_UpperCAmelCase       , _UpperCAmelCase    :			Dict              =					(x - x % 64 for x in (w, h))  # resize to integer multiple of 32
  
  										_UpperCAmelCase    :			Tuple              =					[np.array(i.resize((w, h)       )       )[None, :] for i in image]
  										_UpperCAmelCase    :			Optional[int]              =					np.concatenate(__A		,						axis=0       )
  										_UpperCAmelCase    :			List[Any]              =					np.array(__A       ).astype(np.floataa       ) / 255.0
  										_UpperCAmelCase    :			Dict              =					image.transpose(0		,						3		,						1		,						2       )
  										_UpperCAmelCase    :			List[str]              =					2.0 * image - 1.0
  										_UpperCAmelCase    :			List[Any]              =					torch.from_numpy(__A       )
  					elif isinstance(image[0]		,						torch.Tensor       ):
  										_UpperCAmelCase    :			Any              =					torch.cat(__A		,						dim=0       )
  
  					return image
  
  
  
  
  
  
  class 			UpperCAmelCase_						(       UpperCAmelCase_		):
  
  
  
  						def __init__(  self  :			Tuple  ,			A  :			str  ,			A  :			Tuple  ,			A  :			Optional[int]  ,			A  :			Any  ,			A  :			str  ,			A  :			Optional[int]  ,			A  :			str = 3_5_0  ,			):
  											super().__init__(
  											    vae=A  ,			text_encoder=A  ,			tokenizer=A  ,			unet=A  ,			low_res_scheduler=A  ,			scheduler=A  ,			safety_checker=A  ,			feature_extractor=A  ,			watermarker=A  ,			max_noise_level=A  ,			)
  
  
  
  						def __call__(  self  :			Union[str, Any]  ,			A  :			List[str]  ,			A  :			Optional[Any]  ,			A  :			Tuple = 7_5  ,			A  :			Tuple = 9.0  ,			A  :			Tuple = 2_0  ,			A  :			Optional[Any] = None  ,			A  :			Union[str, Any] = 1  ,			A  :			Union[str, Any] = 0.0  ,			A  :			Dict = None  ,			A  :			Optional[int] = None  ,			A  :			Optional[int] = None  ,			A  :			Any = None  ,			A  :			List[Any] = "pil"  ,			A  :			int = True  ,			A  :			int = None  ,			A  :			List[str] = 1  ,			):
  											self.check_inputs(A  ,			A  ,			A  ,			A		)
  
  											# 2. Define call parameters
  											if prompt is not None and isinstance(A  ,			A		):
  																_UpperCAmelCase    :			Tuple              =					1
  											elif prompt is not None and isinstance(A  ,			A		):
  																_UpperCAmelCase    :			List[Any]              =					len(A		)
  											else:
  																_UpperCAmelCase    :			List[Any]              =					prompt_embeds.shape[0]
  
  											_UpperCAmelCase    :			List[str]              =					self._execution_device
  											# here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
  											# of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
  											# corresponds to doing no classifier free guidance.
  											_UpperCAmelCase    :			List[Any]              =					guidance_scale > 1.0
  
  											# 3. Encode input prompt
  											_UpperCAmelCase    :			Tuple              =					self._encode_prompt(
  											    A  ,			A  ,			A  ,			A  ,			A  ,			prompt_embeds=A  ,			negative_prompt_embeds=A  ,			)
  
  											_UpperCAmelCase    :			str              =					ORT_TO_PT_TYPE[str(text_embeddings.dtype		)]
  
  											# 4. Preprocess image
  											_UpperCAmelCase    :			str              =					preprocess(A		)
  											_UpperCAmelCase    :			Any              =					image.cpu()
  
  											# 5. set timesteps
  											self.scheduler.set_timesteps(A  ,			device=A		)
  											_UpperCAmelCase    :			Tuple              =					self.scheduler.timesteps
  
  											# 5. Add noise to image
  											_UpperCAmelCase    :			Optional[int]              =					torch.tensor([noise_level]  ,			dtype=torch.long  ,			device=A		)
  											_UpperCAmelCase    :			List[Any]              =					torch.randn(image.shape  ,			generator=A  ,			device=A  ,			dtype=A		)
  											_UpperCAmelCase    :			Optional[int]              =					self.low_res_scheduler.add_noise(A  ,			A  ,			A		)
  
  											_UpperCAmelCase    :			int              =					2 if do_classifier_free_guidance else 1
  											_UpperCAmelCase    :			int              =					np.concatenate([image] * batch_multiplier * num_images_per_prompt		)
  											_UpperCAmelCase    :			Optional[Any]              =					np.concatenate([noise_level] * image.shape[0]		)
  
  											# 6. Prepare latent variables
  											_UpperCAmelCase       , _UpperCAmelCase    :			List[Any]              =					image.shape[2:]
  											_UpperCAmelCase    :			Tuple              =					self.prepare_latents(
  											    batch_size * num_images_per_prompt  ,			A  ,			A  ,			A  ,			A  ,			A  ,			A  ,			A  ,			)
  
  											# 7. Check that sizes of image and latents match
  											_UpperCAmelCase    :			str              =					image.shape[1]
  											if NUM_LATENT_CHANNELS + num_channels_image != NUM_UNET_INPUT_CHANNELS:
  																raise ValueError(
  																    "Incorrect configuration settings! The config of `pipeline.unet` expects"
  																    f' {NUM_UNET_INPUT_CHANNELS} but received `num_channels_latents`: {NUM_LATENT_CHANNELS} +'
  																    f' `num_channels_image`: {num_channels_image} '
  																    f' = {NUM_LATENT_CHANNELS+num_channels_image}. Please verify the config of'
  																    " `pipeline.unet` or your `image` input."		)
  
  											# 8. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline
  											_UpperCAmelCase    :			Dict              =					self.prepare_extra_step_kwargs(A  ,			A		)
  
  											_UpperCAmelCase    :			Optional[int]              =					next(
  											    (input.type for input in self.unet.model.get_inputs() if input.name == "timestep")  ,			"tensor(float)"		)
  											_UpperCAmelCase    :			Tuple              =					ORT_TO_NP_TYPE[timestep_dtype]
  
  											# 9. Denoising loop
  											_UpperCAmelCase    :			Dict              =					len(A		) - num_inference_steps * self.scheduler.order
  											with self.progress_bar(total=A		) as progress_bar:
  																for i, t in enumerate(A		):
  																					# expand the latents if we are doing classifier free guidance
  																					_UpperCAmelCase    :			Dict              =					np.concatenate([latents] * 2		) if do_classifier_free_guidance else latents
  
  																					# concat latents, mask, masked_image_latents in the channel dimension
  																					_UpperCAmelCase    :			Tuple              =					self.scheduler.scale_model_input(A  ,			A		)
  																					_UpperCAmelCase    :			Any              =					np.concatenate([latent_model_input, image]  ,			axis=1		)
  
  																					# timestep to tensor
  																					_UpperCAmelCase    :			Dict              =					np.array([t]  ,			dtype=A		)
  
  																					# predict the noise residual
  																					_UpperCAmelCase    :			Tuple              =					self.unet(
  																					    sample=A  ,			timestep=A  ,			encoder_hidden_states=A  ,			class_labels=noise_level.astype(np.intaa		)  ,			)[0]
  
  																					# perform guidance
  																					if do_classifier_free_guidance:
  																										_UpperCAmelCase       , _UpperCAmelCase    :			List[str]              =					np.split(A  ,			2		)
  																					_UpperCAmelCase    :			List[Any]              =					noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
  
  																					# compute the previous noisy sample x_t -> x_t-1
  																					_UpperCAmelCase    :			Any              =					self.scheduler.step(
  																					    torch.from_numpy(A		)  ,			A  ,			A  ,			**A		).prev_sample
  
  																					# call the callback, if provided
  																					if i == len(A		) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
  																										progress_bar.update()
  																										if callback is not None and i % callback_steps == 0:
  																															callback(A  ,			A  ,			A		)
  
  																															  # 10. Post-processing
  											_UpperCAmelCase    :			Optional[Any]              =					self.decode_latents(latents.float()		)
  
  											# 11. Convert to PIL
  											if output_type == "pil":
  																_UpperCAmelCase    :			int              =					self.numpy_to_pil(A		)
  
  											if not return_dict:
  																return (image,)
  
  											return ImagePipelineOutput(images=A		)
  
  
  
  						def 		snake_case_      (  self  :			int  ,			A  :			int		):
  											_UpperCAmelCase    :			List[str]              =					1 / 0.08_333 * latents
  											_UpperCAmelCase    :			Optional[Any]              =					self.vae(latent_sample=A		)[0]
  											_UpperCAmelCase    :			List[Any]              =					np.clip(image / 2 + 0.5  ,			0  ,			1		)
  											_UpperCAmelCase    :			Union[str, Any]              =					image.transpose((0, 2, 3, 1)		)
  											return image
  
  
  
  						def 		snake_case_      (  self  :			Optional[int]  ,			A  :			List[str]  ,			A  :			Optional[int]  ,			A  :			int  ,			A  :			Dict  ,			A  :			Any  ,			A  :			Optional[int] = None  ,			A  :			Optional[Any] = None  ,			):
  											if prompt is not None and isinstance(A  ,			A		):
  																_UpperCAmelCase    :			Tuple              =					1
  											elif prompt is not None and isinstance(A  ,			A		):
  																_UpperCAmelCase    :			Dict              =					len(A		)
  											else:
  																_UpperCAmelCase    :			str              =					prompt_embeds.shape[0]
  
  											if prompt_embeds is None:
  																_UpperCAmelCase    :			List[Any]              =					self.tokenizer(
  																    A  ,			padding="max_length"  ,			max_length=self.tokenizer.model_max_length  ,			truncation=A  ,			return_tensors="pt"  ,			)
  																_UpperCAmelCase    :			int              =					text_inputs.input_ids
  																_UpperCAmelCase    :			List[Any]              =					self.tokenizer(A  ,			padding="longest"  ,			return_tensors="pt"		).input_ids
  
  																if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(
  																    A  ,			A		):
  																					_UpperCAmelCase    :			Union[str, Any]              =					self.tokenizer.batch_decode(
  																					    untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1]		)
  																					logger.warning(
  																					    "The following part of your input was truncated because CLIP can only handle sequences up to"
  																					    f' {self.tokenizer.model_max_length} tokens: {removed_text}'		)
  
  																# no positional arguments to text_encoder
  																_UpperCAmelCase    :			Optional[Any]              =					self.text_encoder(
  																    input_ids=text_input_ids.int().to(A		)  ,			)
  																_UpperCAmelCase    :			List[Any]              =					prompt_embeds[0]
  
  											_UpperCAmelCase       , _UpperCAmelCase       , _UpperCAmelCase    :			Tuple              =					prompt_embeds.shape
  											# duplicate text embeddings for each generation per prompt, using mps friendly method
  											_UpperCAmelCase    :			Union[str, Any]              =					prompt_embeds.repeat(1  ,			A		)
  											_UpperCAmelCase    :			List[Any]              =					prompt_embeds.reshape(bs_embed * num_images_per_prompt  ,			A  ,			-1		)
  
  											# get unconditional embeddings for classifier free guidance
  											if do_classifier_free_guidance and negative_prompt_embeds is None:
  																_UpperCAmelCase    :			int              =					4_2
  																if negative_prompt is None:
  																					_UpperCAmelCase    :			Optional[Any]              =					[""] * batch_size
  																elif type(A		) is not type(A		):
  																					raise TypeError(
  																					    f'`negative_prompt` should be the same type to `prompt`, but got {type(A		)} !='
  																					    f' {type(A		)}.'		)
  																elif isinstance(A  ,			A		):
  																					_UpperCAmelCase    :			List[str]              =					[negative_prompt]
  																elif batch_size != len(A		):
  																					raise ValueError(
  																					    f'`negative_prompt`: {negative_prompt} has batch size {len(A		)}, but `prompt`:'
  																					    f' {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches'
  																					    " the batch size of `prompt`."		)
  																else:
  																					_UpperCAmelCase    :			Union[str, Any]              =					negative_prompt
  
  																_UpperCAmelCase    :			Tuple              =					text_input_ids.shape[-1]
  																_UpperCAmelCase    :			List[Any]              =					self.tokenizer(
  																    A  ,			padding="max_length"  ,			max_length=A  ,			truncation=A  ,			return_tensors="pt"  ,			)
  
  																# if hasattr(uncond_input, "attention_mask"):
  																#     attention_mask = uncond_input.attention_mask.to(device)
  																# else:
  																#     attention_mask = None
  
  																_UpperCAmelCase    :			List[str]              =					self.text_encoder(
  																    input_ids=uncond_input.input_ids.int().to(A		)  ,			)
  																_UpperCAmelCase    :			Any              =					uncond_embeddings[0]
  
  											if do_classifier_free_guidance:
  																_UpperCAmelCase    :			Union[str, Any]              =					uncond_embeddings.shape[1]
  																# duplicate unconditional embeddings for each generation per prompt, using mps friendly method
  																_UpperCAmelCase    :			List[str]              =					uncond_embeddings.repeat(1  ,			A		)
  																_UpperCAmelCase    :			str              =					uncond_embeddings.reshape(batch_size * num_images_per_prompt  ,			A  ,			-1		)
  
  																# For classifier free guidance, we need to do two forward passes.
  																# Here we concatenate the unconditional and text embeddings into a single batch
  																# to avoid doing two forward passes
  																_UpperCAmelCase    :			List[str]              =					np.concatenate([uncond_embeddings, prompt_embeds]		)
  
  											return prompt_embeds
  
style_context: 
  
  
  
  """simple docstring"""
  
  
  
  
  import argparse
  
  import torch
  
  from transformers import ImageGPTConfig, ImageGPTForCausalLM, load_tf_weights_in_imagegpt
  from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging
  
  
  logging.set_verbosity_info()
  
  def 		__snake_case		(   SCREAMING_SNAKE_CASE__			:		Optional[Any]		,						SCREAMING_SNAKE_CASE__			:		Tuple		,						SCREAMING_SNAKE_CASE__			:		Any       )						->     Dict:
  
  
  
  
  
       '''simple docstring'''
  
       _UpperCAmelCase    :			Any              =					{"small": (512, 8, 24), "medium": (1_024, 8, 36), "large": (1_536, 16, 48)}
       _UpperCAmelCase       , _UpperCAmelCase       , _UpperCAmelCase    :			str              =					MODELS[model_size]  # set model hyperparameters
       _UpperCAmelCase    :			Tuple              =					ImageGPTConfig(n_embd=SCREAMING_SNAKE_CASE__		,						n_layer=SCREAMING_SNAKE_CASE__		,						n_head=SCREAMING_SNAKE_CASE__       )
       _UpperCAmelCase    :			int              =					ImageGPTForCausalLM(SCREAMING_SNAKE_CASE__       )
  
       # Load weights from numpy
       load_tf_weights_in_imagegpt(SCREAMING_SNAKE_CASE__		,						SCREAMING_SNAKE_CASE__		,						SCREAMING_SNAKE_CASE__       )
  
       # Save pytorch-model
       _UpperCAmelCase    :			Union[str, Any]              =					pytorch_dump_folder_path + "/" + WEIGHTS_NAME
       _UpperCAmelCase    :			int              =					pytorch_dump_folder_path + "/" + CONFIG_NAME
       print(f'Save PyTorch model to {pytorch_weights_dump_path}'       )
       torch.save(model.state_dict()		,						SCREAMING_SNAKE_CASE__       )
       print(f'Save configuration file to {pytorch_config_dump_path}'       )
       with open(SCREAMING_SNAKE_CASE__		,						"w"		,						encoding="utf-8"       ) as f:
            f.write(config.to_json_string()       )
  
  
  if __name__ == "__main__":
   _lowerCAmelCase       :      List[str]							=							argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       "--imagegpt_checkpoint_path",
       default=None,
       type=str,
       required=True,
       help="Path to the TensorFlow checkpoint path.",
   )
   parser.add_argument(
       "--model_size",
       default=None,
       type=str,
       required=True,
       help="Size of the model (can be either 'small', 'medium' or 'large').",
   )
   parser.add_argument(
       "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
   )
   _lowerCAmelCase       :      Optional[int]							=							parser.parse_args()
   convert_imagegpt_checkpoint_to_pytorch(
       args.imagegpt_checkpoint_path, args.model_size, args.pytorch_dump_folder_path
   )
  