




import argparse

# utilities to import the model weights and config file
import os
import pickle as pkl

# PyTorch + new model classes
import torch
from torch import nn

from transformers import AutoTokenizer, MegaConfig, MegaForMaskedLM


# import the EncoderLayer class used to pretrain
# !! NOTE !! this requires the version of fairseq that is built when you install the Mega source
try:
				from fairseq.modules.mega_layer import MegaEncoderLayer
except ImportError:
				raise ImportError('You need to install the version of fairseq from the Mega repo!')






class 					__lowerCAmelCase				( nn.Module				):







			def __init__( self					:    str					,					snake_case__					:    Any					,					snake_case__					:    str					,					snake_case__					:    str   ):




									"""simple docstring"""


									super().__init__()
									_UpperCAmelCase									=  mega_args
									_UpperCAmelCase									=  nn.Embedding(snake_case__					,					self.mega_args.encoder_embed_dim   )
									_UpperCAmelCase									=  nn.ModuleList([MegaEncoderLayer(self.mega_args   ) for _ in range(snake_case__   )]   )
									_UpperCAmelCase									=  depth







			def UpperCamelCase    ( self					:    List[Any]					,					snake_case__					:    str					,					snake_case__					:    Optional[int]					,					snake_case__					:    List[str]=True					,					snake_case__					:    Tuple=0   ):




									"""simple docstring"""


									if batch_first:
															_UpperCAmelCase									=  input_ids.T

									# to make things more confusing, Mega expects the attention mask to
									# be (batch, time), but with values of 0 (normal token) and 1 (ignore token)
									# which is the opposite of what HF returns
									if ignore_mask_value == 0:
															_UpperCAmelCase									=  1 - attention_mask

									# get token embeddings from IDs
									_UpperCAmelCase									=  self.embedding_layer(snake_case__   )

									# pass through the Mega layers
									# input is (time, batch, encoder dim) and output is the same
									for encoder in self.encoders:
															_UpperCAmelCase									=  encoder(snake_case__					,					snake_case__   )

									# return according to the shape specified
									if batch_first:
															# (T, B, H) --> (B, T, H)
															return torch.transpose(snake_case__					,					0					,					1   )
									else:
															return embeds






class 					__lowerCAmelCase				( nn.Module				):







			def __init__( self					:    Optional[int]					,					snake_case__					:    Union[str, Any]					,					snake_case__					:    Optional[Any]					,					snake_case__					:    List[Any]   ):




									"""simple docstring"""


									super().__init__()
									_UpperCAmelCase									=  MegaLM(snake_case__					,					snake_case__					,					snake_case__   )
									_UpperCAmelCase									=  nn.Linear(mega_args.encoder_embed_dim					,					snake_case__   )
									_UpperCAmelCase									=  nn.Dropout(p=0.1   )







			def UpperCamelCase    ( self					:    Optional[int]					,					snake_case__					:    Optional[int]					,					snake_case__					:    int					,					snake_case__					:    Dict=True					,					snake_case__					:    Union[str, Any]=0   ):




									"""simple docstring"""


									_UpperCAmelCase									=  self.mega(snake_case__					,					snake_case__					,					snake_case__					,					snake_case__   )
									return self.mlm_head(self.dropout(snake_case__   )   )




def 							__SCREAMING_SNAKE_CASE						(    snake_case_			,					snake_case_			,					snake_case_		):

						'''simple docstring'''


						with open(os.path.join(snake_case_			,					"model_args.pkl"		)			,					"rb"		) as f:
												_UpperCAmelCase									=  pkl.load(snake_case_		)

						# load the original encoder
						_UpperCAmelCase									=  OriginalMegaForMaskedLM(**snake_case_		).eval()

						# load its weights
						print(
						    "Original Mega encoder:"			,					original_mlm.mega.load_state_dict(
						        torch.load(os.path.join(snake_case_			,					"encoder_weights.pt"		)			,					map_location="cpu"		)		)			,					)
						print(
						    "Original Mega MLM layer:"			,					original_mlm.mlm_head.load_state_dict(
						        torch.load(os.path.join(snake_case_			,					"mlm_head_weights.pt"		)			,					map_location="cpu"		)		)			,					)

						# create a new config from the old one
						_UpperCAmelCase									=  MegaConfig(
						    num_hidden_layers=mega_original_args["depth"]			,					vocab_size=mega_original_args["vocab_size"]			,					hidden_size=mega_original_args["mega_args"].encoder_embed_dim			,					shared_representation_size=mega_original_args["mega_args"].encoder_z_dim			,					intermediate_size=mega_original_args["mega_args"].encoder_hidden_dim			,					ema_projection_size=mega_original_args["mega_args"].encoder_n_dim			,					dropout_prob=mega_original_args["mega_args"].dropout			,					attention_probs_dropout_prob=mega_original_args["mega_args"].attention_dropout			,					hidden_dropout_prob=mega_original_args["mega_args"].hidden_dropout			,					activation=mega_original_args["mega_args"].activation_fn			,					attention_activation=mega_original_args["mega_args"].attention_activation_fn			,					bidirectional=mega_original_args["mega_args"].bidirectional			,					use_chunking=mega_original_args["mega_args"].encoder_chunk_size > 0			,					chunk_size=mega_original_args["mega_args"].encoder_chunk_size			,					truncation=mega_original_args["mega_args"].truncation_length			,					normalization_type=mega_original_args["mega_args"].normalization_type			,					normalize_before_mega=snake_case_			,					norm_affine=snake_case_			,					use_feature_dropout=mega_original_args["mega_args"].feature_dropout			,					relative_positional_bias=mega_original_args["mega_args"].rel_pos_bias			,					max_positions=mega_original_args["mega_args"].max_source_positions			,					nffn_hidden_size=mega_original_args["mega_args"].encoder_ffn_embed_dim			,					normalize_before_ffn=mega_original_args["mega_args"].normalize_before			,					nffn_activation_dropout_prob=0.0			,					add_token_type_embeddings=snake_case_			,					add_lm_hidden_dense_layer=snake_case_			,					)

						_UpperCAmelCase									=  MegaForMaskedLM(snake_case_		).eval()

						# the originl checkpoint just uses nn.Embedding for the word embeddings
						# we use a wrapper module for embeddings to add support for positional embeddings
						_UpperCAmelCase									=  original_mlm.mega.embedding_layer.weight

						# modify the state dictionary of the original checkpoint to account for naming issues in the Hugging Face
						# ecosystem -- any names containing "beta" or "gamma" aren't safe to use and are renamed upon _load_pretrained,
						# also renaming previously confusing parameter names
						_UpperCAmelCase									=  original_mlm.mega.encoders.state_dict()
						_UpperCAmelCase									=  {}
						for module_name in original_state_dict.keys():
												_UpperCAmelCase									=  None
												# have to handle gamma, beta, and alpha differently due to their use
												# in multiple modules within the original repository;
												# beta is used in EMA, MovingAverageGatedAttention, and RotaryRelativePositionalBias, and must be renamed due to flax/tf weights
												# the EMA sublayer was renamed from "move" to "ema_gate" for readability, so that is also done here
												if "beta" in module_name:
																		# EMA sub-layers were always called "move" in the original repo
																		if "move.beta" in module_name:
																								_UpperCAmelCase									=  module_name.replace("move.beta"			,					"ema_gate.ema_expansion_matrix"		)
																		elif "mega_layer.beta" in module_name:
																								_UpperCAmelCase									=  module_name.replace("beta"			,					"qk_bias"		)
																		else:
																								_UpperCAmelCase									=  module_name.replace("beta"			,					"b_param"		)
        # beta is used in EMA and MovingAverageGatedAttention, and must be renamed due to flax/tf weights
												elif "gamma" in module_name:
																		if "move.gamma" in module_name:
																								_UpperCAmelCase									=  module_name.replace("move.gamma"			,					"ema_gate.kernel_projection_matrix"		)
																		elif "mega_layer.gamma" in module_name:
																								_UpperCAmelCase									=  module_name.replace("gamma"			,					"qk_weight"		)
																		else:
																								_UpperCAmelCase									=  module_name.replace("gamma"			,					"g_param"		)
        # alpha is used in EMA and positional bias; renaming to improve readability
												elif "move.alpha" in module_name:
																		_UpperCAmelCase									=  module_name.replace("move.alpha"			,					"ema_gate.decay_factor"		)
												# delta is only used in EMA; renaming to improve readability
												elif "move.delta" in module_name:
																		_UpperCAmelCase									=  module_name.replace("move.delta"			,					"ema_gate.damping_factor"		)
												# omega is only used in EMA; renaming to improve readability
												elif "omega" in module_name:
																		_UpperCAmelCase									=  module_name.replace("move.omega"			,					"ema_gate.residual_weight"		)

												if new_module_name:
																		_UpperCAmelCase									=  new_module_name

						if len(snake_case_		) != 0:
												print(f"""Renaming these keys: {updated_keys.keys()}"""		)
						else:
												print("No need to rename state dict entries"		)
						for old, new in updated_keys.items():
												_UpperCAmelCase									=  original_state_dict.pop(snake_case_		)

						# now attempt to load the state dictionary with updated names
						# note that we now call it `mega.layers` instead of `mega.encoders` due to hugging face style
						print("HF Mega encoder:"			,					hf_mlm.mega.layers.load_state_dict(snake_case_		)		)

						# load the MLM head weights directly
						print(
						    "HF Mega MLM layer:"			,					hf_mlm.mlm_head.load_state_dict(
						        torch.load(os.path.join(snake_case_			,					"mlm_head_weights.pt"		)			,					map_location="cpu"		)		)			,					)

						# test on a randomly generated input sequence
						_UpperCAmelCase									=  torch.randint(0			,					hf_config.vocab_size			,					size=(4, 256)		)
						_UpperCAmelCase									=  torch.ones_like(snake_case_		)
						# mask a few tokens to make sure masking is applied appropriately :)
						_UpperCAmelCase									=  0

						# run forward passes
						_UpperCAmelCase									=  original_mlm(snake_case_			,					snake_case_			,					batch_first=snake_case_			,					ignore_mask_value=0		)
						_UpperCAmelCase									=  hf_mlm(snake_case_			,					snake_case_		)[0]

						# print shapes and diff
						print(f"""original output {original_output.shape}"""		)
						print(f"""hf output {hf_output.shape}"""		)
						print(f"""max diff: {(original_output - hf_output).max()}"""		)  # 0.0
						_UpperCAmelCase									=  torch.allclose(snake_case_			,					snake_case_			,					atol=1e-3		)

						if success:
												print("Yay!"		)
												hf_mlm.save_pretrained(snake_case_		)
						else:
												raise RuntimeError(f"""Something's broken :(\nOriginal:\n{original_output}\n\nHF\n{hf_output}\n{hf_mlm}"""		)

						if includes_tokenizer:
												print("Transferring tokenizer"		)
												_UpperCAmelCase									=  AutoTokenizer.from_pretrained(snake_case_		)
												tokenizer.save_pretrained(snake_case_		)


if __name__ == "__main__":
				lowercase_			:       Union[str, Any]						       =				argparse.ArgumentParser()

				parser.add_argument(
				    '--pretrained_checkpoint_path',
				    default=None,
				    type=str,
				    required=True,
				    help='Point to the directory containing your model weights using the official Mega repo',
				)

				parser.add_argument(
				    '--output_path', default=None, type=str, required=True, help='Location to save the Hugging Face version'
				)

				parser.add_argument(
				    '--includes_tokenizer',
				    action='store_true',
				    help='Use this flag if there is a Hugging Face tokenizer in the original checkpoint repo',
				)

				lowercase_			:       Optional[int]						       =				parser.parse_args()

				convert_checkpoint_to_huggingface(args.pretrained_checkpoint_path, args.output_path, args.includes_tokenizer)










import argparse
import os

import torch
from torchvision.datasets.utils import download_url

from diffusers import AutoencoderKL, DDIMScheduler, DiTPipeline, TransformeraDModel


lowercase_			:       Tuple						       =				{5_12: 'DiT-XL-2-512x512.pt', 2_56: 'DiT-XL-2-256x256.pt'}


def 							__SCREAMING_SNAKE_CASE						(    snake_case_		):

						'''simple docstring'''


						_UpperCAmelCase									=  f"""pretrained_models/{model_name}"""
						if not os.path.isfile(snake_case_		):
												os.makedirs("pretrained_models"			,					exist_ok=snake_case_		)
												_UpperCAmelCase									=  f"""https://dl.fbaipublicfiles.com/DiT/models/{model_name}"""
												download_url(snake_case_			,					"pretrained_models"		)
						_UpperCAmelCase									=  torch.load(snake_case_			,					map_location=lambda snake_case_			,					snake_case_		: storage		)
						return model


def 							__SCREAMING_SNAKE_CASE						(    snake_case_		):

						'''simple docstring'''


						_UpperCAmelCase									=  download_model(pretrained_models[args.image_size]		)

						_UpperCAmelCase									=  state_dict["x_embedder.proj.weight"]
						_UpperCAmelCase									=  state_dict["x_embedder.proj.bias"]
						state_dict.pop("x_embedder.proj.weight"		)
						state_dict.pop("x_embedder.proj.bias"		)

						for depth in range(28		):
												_UpperCAmelCase									=  state_dict[
												    "t_embedder.mlp.0.weight"
												]
												_UpperCAmelCase									=  state_dict[
												    "t_embedder.mlp.0.bias"
												]
												_UpperCAmelCase									=  state_dict[
												    "t_embedder.mlp.2.weight"
												]
												_UpperCAmelCase									=  state_dict[
												    "t_embedder.mlp.2.bias"
												]
												_UpperCAmelCase									=  state_dict[
												    "y_embedder.embedding_table.weight"
												]

												_UpperCAmelCase									=  state_dict[
												    f"""blocks.{depth}.adaLN_modulation.1.weight"""
												]
												_UpperCAmelCase									=  state_dict[
												    f"""blocks.{depth}.adaLN_modulation.1.bias"""
												]

												_UpperCAmelCase							,				_UpperCAmelCase							,				_UpperCAmelCase									=  torch.chunk(state_dict[f"""blocks.{depth}.attn.qkv.weight"""]			,					3			,					dim=0		)
												_UpperCAmelCase							,				_UpperCAmelCase							,				_UpperCAmelCase									=  torch.chunk(state_dict[f"""blocks.{depth}.attn.qkv.bias"""]			,					3			,					dim=0		)

												_UpperCAmelCase									=  q
												_UpperCAmelCase									=  q_bias
												_UpperCAmelCase									=  k
												_UpperCAmelCase									=  k_bias
												_UpperCAmelCase									=  v
												_UpperCAmelCase									=  v_bias

												_UpperCAmelCase									=  state_dict[
												    f"""blocks.{depth}.attn.proj.weight"""
												]
												_UpperCAmelCase									=  state_dict[f"""blocks.{depth}.attn.proj.bias"""]

												_UpperCAmelCase									=  state_dict[f"""blocks.{depth}.mlp.fc1.weight"""]
												_UpperCAmelCase									=  state_dict[f"""blocks.{depth}.mlp.fc1.bias"""]
												_UpperCAmelCase									=  state_dict[f"""blocks.{depth}.mlp.fc2.weight"""]
												_UpperCAmelCase									=  state_dict[f"""blocks.{depth}.mlp.fc2.bias"""]

												state_dict.pop(f"""blocks.{depth}.attn.qkv.weight"""		)
												state_dict.pop(f"""blocks.{depth}.attn.qkv.bias"""		)
												state_dict.pop(f"""blocks.{depth}.attn.proj.weight"""		)
												state_dict.pop(f"""blocks.{depth}.attn.proj.bias"""		)
												state_dict.pop(f"""blocks.{depth}.mlp.fc1.weight"""		)
												state_dict.pop(f"""blocks.{depth}.mlp.fc1.bias"""		)
												state_dict.pop(f"""blocks.{depth}.mlp.fc2.weight"""		)
												state_dict.pop(f"""blocks.{depth}.mlp.fc2.bias"""		)
												state_dict.pop(f"""blocks.{depth}.adaLN_modulation.1.weight"""		)
												state_dict.pop(f"""blocks.{depth}.adaLN_modulation.1.bias"""		)

						state_dict.pop("t_embedder.mlp.0.weight"		)
						state_dict.pop("t_embedder.mlp.0.bias"		)
						state_dict.pop("t_embedder.mlp.2.weight"		)
						state_dict.pop("t_embedder.mlp.2.bias"		)
						state_dict.pop("y_embedder.embedding_table.weight"		)

						_UpperCAmelCase									=  state_dict["final_layer.adaLN_modulation.1.weight"]
						_UpperCAmelCase									=  state_dict["final_layer.adaLN_modulation.1.bias"]
						_UpperCAmelCase									=  state_dict["final_layer.linear.weight"]
						_UpperCAmelCase									=  state_dict["final_layer.linear.bias"]

						state_dict.pop("final_layer.linear.weight"		)
						state_dict.pop("final_layer.linear.bias"		)
						state_dict.pop("final_layer.adaLN_modulation.1.weight"		)
						state_dict.pop("final_layer.adaLN_modulation.1.bias"		)

						# DiT XL/2
						_UpperCAmelCase									=  TransformeraDModel(
						    sample_size=args.image_size // 8			,					num_layers=28			,					attention_head_dim=72			,					in_channels=4			,					out_channels=8			,					patch_size=2			,					attention_bias=snake_case_			,					num_attention_heads=16			,					activation_fn="gelu-approximate"			,					num_embeds_ada_norm=1000			,					norm_type="ada_norm_zero"			,					norm_elementwise_affine=snake_case_			,					)
						transformer.load_state_dict(snake_case_			,					strict=snake_case_		)

						_UpperCAmelCase									=  DDIMScheduler(
						    num_train_timesteps=1000			,					beta_schedule="linear"			,					prediction_type="epsilon"			,					clip_sample=snake_case_			,					)

						_UpperCAmelCase									=  AutoencoderKL.from_pretrained(args.vae_model		)

						_UpperCAmelCase									=  DiTPipeline(transformer=snake_case_			,					vae=snake_case_			,					scheduler=snake_case_		)

						if args.save:
												pipeline.save_pretrained(args.checkpoint_path		)


if __name__ == "__main__":
				lowercase_			:       Union[str, Any]						       =				argparse.ArgumentParser()

				parser.add_argument(
				    '--image_size',
				    default=2_56,
				    type=int,
				    required=False,
				    help='Image size of pretrained model, either 256 or 512.',
				)
				parser.add_argument(
				    '--vae_model',
				    default='stabilityai/sd-vae-ft-ema',
				    type=str,
				    required=False,
				    help='Path to pretrained VAE model, either stabilityai/sd-vae-ft-mse or stabilityai/sd-vae-ft-ema.',
				)
				parser.add_argument(
				    '--save', default=True, type=bool, required=False, help='Whether to save the converted pipeline or not.'
				)
				parser.add_argument(
				    '--checkpoint_path', default=None, type=str, required=True, help='Path to the output pipeline.'
				)

				lowercase_			:       Tuple						       =				parser.parse_args()
				main(args)




