





'''simple docstring'''







import argparse

import torch

from transformers import OpenAIGPTConfig, OpenAIGPTModel, load_tf_weights_in_openai_gpt
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()






def  _lowerCamelCase				( lowercase						:      Any    ,							lowercase						:      Optional[int]    ,							lowercase						:      Dict						)	->	Optional[Any]:
				# Construct model
				if openai_config_file == "":
								_a								= OpenAIGPTConfig()
				else:
								_a								= OpenAIGPTConfig.from_json_file(lowercase						)
				_a								= OpenAIGPTModel(lowercase						)

				# Load weights from numpy
				load_tf_weights_in_openai_gpt(lowercase    ,							lowercase    ,							lowercase						)

				# Save pytorch-model
				_a								= pytorch_dump_folder_path + "/" + WEIGHTS_NAME
				_a								= pytorch_dump_folder_path + "/" + CONFIG_NAME
				print(F'Save PyTorch model to {pytorch_weights_dump_path}'						)
				torch.save(model.state_dict()    ,							lowercase						)
				print(F'Save configuration file to {pytorch_config_dump_path}'						)
				with open(lowercase    ,							"w"    ,							encoding="utf-8"						) as f:
								f.write(config.to_json_string()						)


if __name__ == "__main__":
					lowerCAmelCase_					:    Union[str, Any]      	=			argparse.ArgumentParser()
					# Required parameters
					parser.add_argument(
					    '--openai_checkpoint_folder_path',
					    default=None,
					    type=str,
					    required=True,
					    help='Path to the TensorFlow checkpoint path.',
					)
					parser.add_argument(
					    '--pytorch_dump_folder_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
					)
					parser.add_argument(
					    '--openai_config_file',
					    default='',
					    type=str,
					    help=(
					        'An optional config json file corresponding to the pre-trained OpenAI model. \n'
					        'This specifies the model architecture.'
					    ),
					)
					lowerCAmelCase_					:    List[Any]      	=			parser.parse_args()
					convert_openai_checkpoint_to_pytorch(
					    args.openai_checkpoint_folder_path, args.openai_config_file, args.pytorch_dump_folder_path
					)







'''simple docstring'''







import torch
from torch import nn

from ...configuration_utils import ConfigMixin, register_to_config
from ...models import ModelMixin
class 				__SCREAMING_SNAKE_CASE  (lowerCamelCase_       ,							lowerCamelCase_      ):






				"""simple docstring"""







				@register_to_config
				def __init__(  self     :					Dict					,				*,
				    __a     :					int = 4					,				__a     :					int = 7_68					,				__a     :					int					,				__a     :					int					,				):
								super().__init__()

								_a								= nn.Parameter(torch.zeros(__a					)					)

								# parameters for additional clip time embeddings
								_a								= nn.Linear(__a					,				__a					)
								_a								= nn.Linear(__a					,				__a					)

								# parameters for encoder hidden states
								_a								= clip_extra_context_tokens
								_a								= nn.Linear(
								    __a					,				self.clip_extra_context_tokens * cross_attention_dim					)
								_a								= nn.Linear(__a					,				__a					)
								_a								= nn.LayerNorm(__a					)




				def   UpperCamelCase__   (  self     :					Optional[Any]					,				*, __a     :					Tuple					,				__a     :					Union[str, Any]					,				__a     :					Any					,				__a     :					List[Any]					):
								if do_classifier_free_guidance:
												# Add the classifier free guidance embeddings to the image embeddings
												_a								= image_embeddings.shape[0]
												_a								= self.learned_classifier_free_guidance_embeddings.unsqueeze(0					)
												_a								= classifier_free_guidance_embeddings.expand(
												    __a					,				-1					)
												_a								= torch.cat([classifier_free_guidance_embeddings, image_embeddings]					,				dim=0					)

								# The image embeddings batch size and the text embeddings batch size are equal
								assert image_embeddings.shape[0] == prompt_embeds.shape[0]

								_a								= prompt_embeds.shape[0]

								# "Specifically, we modify the architecture described in Nichol et al. (2021) by projecting and
								# adding CLIP embeddings to the existing timestep embedding, ...
								_a								= self.embedding_proj(__a					)
								_a								= self.clip_image_embeddings_project_to_time_embeddings(__a					)
								_a								= time_projected_image_embeddings + time_projected_prompt_embeds

								# ... and by projecting CLIP embeddings into four
								# extra tokens of context that are concatenated to the sequence of outputs from the GLIDE text encoder"
								_a								= self.clip_extra_context_tokens_proj(__a					)
								_a								= clip_extra_context_tokens.reshape(__a					,				-1					,				self.clip_extra_context_tokens					)
								_a								= clip_extra_context_tokens.permute(0					,				2					,				1					)

								_a								= self.encoder_hidden_states_proj(__a					)
								_a								= self.text_encoder_hidden_states_norm(__a					)
								_a								= torch.cat([clip_extra_context_tokens, text_encoder_hidden_states]					,				dim=1					)

								return text_encoder_hidden_states, additive_clip_time_embeddings
