

import argparse
import os

import torch
from torchvision.datasets.utils import download_url

from diffusers import AutoencoderKL, DDIMScheduler, DiTPipeline, TransformeraDModel


lowerCAmelCase__	:  Any 		={512: '''DiT-XL-2-512x512.pt''', 256: '''DiT-XL-2-256x256.pt'''}






def 			__lowercase     (				a__     )       ->				List[Any]:
							__SCREAMING_SNAKE_CASE								=      f"""pretrained_models/{model_name}"""
							if not os.path.isfile(a__     ):
														os.makedirs('pretrained_models'							,     exist_ok=a__     )
														__SCREAMING_SNAKE_CASE								=      f"""https://dl.fbaipublicfiles.com/DiT/models/{model_name}"""
														download_url(a__							,     'pretrained_models'     )
							__SCREAMING_SNAKE_CASE								=      torch.load(a__							,     map_location=lambda a__							,     a__     : storage     )
							return model






def 			__lowercase     (				a__     )       ->				Optional[Any]:
							__SCREAMING_SNAKE_CASE								=      download_model(pretrained_models[args.image_size]     )

							__SCREAMING_SNAKE_CASE								=      state_dict["""x_embedder.proj.weight"""]
							__SCREAMING_SNAKE_CASE								=      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     ):
														__SCREAMING_SNAKE_CASE								=      state_dict[
														    """t_embedder.mlp.0.weight"""
														]
														__SCREAMING_SNAKE_CASE								=      state_dict[
														    """t_embedder.mlp.0.bias"""
														]
														__SCREAMING_SNAKE_CASE								=      state_dict[
														    """t_embedder.mlp.2.weight"""
														]
														__SCREAMING_SNAKE_CASE								=      state_dict[
														    """t_embedder.mlp.2.bias"""
														]
														__SCREAMING_SNAKE_CASE								=      state_dict[
														    """y_embedder.embedding_table.weight"""
														]

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

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

														__SCREAMING_SNAKE_CASE								=      q
														__SCREAMING_SNAKE_CASE								=      q_bias
														__SCREAMING_SNAKE_CASE								=      k
														__SCREAMING_SNAKE_CASE								=      k_bias
														__SCREAMING_SNAKE_CASE								=      v
														__SCREAMING_SNAKE_CASE								=      v_bias

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

														__SCREAMING_SNAKE_CASE								=      state_dict[f"""blocks.{depth}.mlp.fc1.weight"""]
														__SCREAMING_SNAKE_CASE								=      state_dict[f"""blocks.{depth}.mlp.fc1.bias"""]
														__SCREAMING_SNAKE_CASE								=      state_dict[f"""blocks.{depth}.mlp.fc2.weight"""]
														__SCREAMING_SNAKE_CASE								=      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'     )

							__SCREAMING_SNAKE_CASE								=      state_dict["""final_layer.adaLN_modulation.1.weight"""]
							__SCREAMING_SNAKE_CASE								=      state_dict["""final_layer.adaLN_modulation.1.bias"""]
							__SCREAMING_SNAKE_CASE								=      state_dict["""final_layer.linear.weight"""]
							__SCREAMING_SNAKE_CASE								=      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
							__SCREAMING_SNAKE_CASE								=      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=a__							,     num_attention_heads=16							,     activation_fn='gelu-approximate'							,     num_embeds_ada_norm=10_00							,     norm_type='ada_norm_zero'							,     norm_elementwise_affine=a__							,     )
							transformer.load_state_dict(a__							,     strict=a__     )

							__SCREAMING_SNAKE_CASE								=      DDIMScheduler(
							    num_train_timesteps=10_00							,     beta_schedule='linear'							,     prediction_type='epsilon'							,     clip_sample=a__							,     )

							__SCREAMING_SNAKE_CASE								=      AutoencoderKL.from_pretrained(args.vae_model     )

							__SCREAMING_SNAKE_CASE								=      DiTPipeline(transformer=a__							,     vae=a__							,     scheduler=a__     )

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


if __name__ == "__main__":
			lowerCAmelCase__	:  Any 		=argparse.ArgumentParser()

			parser.add_argument(
			    '''--image_size''',
			    default=256,
			    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.'''
			)

			lowerCAmelCase__	:  str 		=parser.parse_args()
			main(args)











def 			__lowercase     (				a__							,     a__     )       ->				List[str]:
							if n == 0:
														return 1

							elif n % 2 == 1:
														return binary_exponentiation(a__							,     n - 1     ) * a

							else:
														__SCREAMING_SNAKE_CASE								=      binary_exponentiation(a__							,     n / 2     )
														return b * b


if __name__ == "__main__":
			try:
						lowerCAmelCase__	:  str 		=int(input('''Enter Base : ''').strip())
						lowerCAmelCase__	:  Optional[int] 		=int(input('''Enter Power : ''').strip())
			except ValueError:
						print('''Invalid literal for integer''')

			lowerCAmelCase__	:  Any 		=binary_exponentiation(BASE, POWER)
			print(F'''{BASE}^({POWER}) : {RESULT}''')






