code: import argparse
  import os
  
  import torch
  from torchvision.datasets.utils import download_url
  
  from diffusers import AutoencoderKL, DDIMScheduler, DiTPipeline, TransformeraDModel
  
  
  UpperCAmelCase					=				{5_12: '''DiT-XL-2-512x512.pt''', 2_56: '''DiT-XL-2-256x256.pt'''}
  
  
  def SCREAMING_SNAKE_CASE				(     lowercase_:	Dict				):
         _UpperCamelCase     :       List[str]  						=  F"pretrained_models/{model_name}"
         if not os.path.isfile(lowerCamelCase__				):
                os.makedirs('pretrained_models'		,						exist_ok=lowerCamelCase__				)
                _UpperCamelCase     :       Tuple  						=  F"https://dl.fbaipublicfiles.com/DiT/models/{model_name}"
                download_url(lowerCamelCase__		,						'pretrained_models'				)
         _UpperCamelCase     :       Any  						=  torch.load(lowerCamelCase__		,						map_location=lambda lowercase_		,						lowercase_				: storage				)
         return model
  
  
  def SCREAMING_SNAKE_CASE				(     lowercase_:	Union[str, Any]				):
         _UpperCamelCase     :       Optional[int]  						=  download_model(pretrained_models[args.image_size]				)
  
         _UpperCamelCase     :       List[str]  						=  state_dict['x_embedder.proj.weight']
         _UpperCamelCase     :       Optional[int]  						=  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     :       Optional[Any]  						=  state_dict[
                    't_embedder.mlp.0.weight'
                ]
                _UpperCamelCase     :       Tuple  						=  state_dict[
                    't_embedder.mlp.0.bias'
                ]
                _UpperCamelCase     :       List[Any]  						=  state_dict[
                    't_embedder.mlp.2.weight'
                ]
                _UpperCamelCase     :       List[Any]  						=  state_dict[
                    't_embedder.mlp.2.bias'
                ]
                _UpperCamelCase     :       List[str]  						=  state_dict[
                    'y_embedder.embedding_table.weight'
                ]
  
                _UpperCamelCase     :       List[str]  						=  state_dict[
                    F"blocks.{depth}.adaLN_modulation.1.weight"
                ]
                _UpperCamelCase     :       Any  						=  state_dict[
                    F"blocks.{depth}.adaLN_modulation.1.bias"
                ]
  
                _UpperCamelCase						,      _UpperCamelCase						,      _UpperCamelCase     :       Tuple  						=  torch.chunk(state_dict[F"blocks.{depth}.attn.qkv.weight"]		,						3		,						dim=0				)
                _UpperCamelCase						,      _UpperCamelCase						,      _UpperCamelCase     :       int  						=  torch.chunk(state_dict[F"blocks.{depth}.attn.qkv.bias"]		,						3		,						dim=0				)
  
                _UpperCamelCase     :       Optional[Any]  						=  q
                _UpperCamelCase     :       Any  						=  q_bias
                _UpperCamelCase     :       List[Any]  						=  k
                _UpperCamelCase     :       str  						=  k_bias
                _UpperCamelCase     :       int  						=  v
                _UpperCamelCase     :       List[str]  						=  v_bias
  
                _UpperCamelCase     :       Union[str, Any]  						=  state_dict[
                    F"blocks.{depth}.attn.proj.weight"
                ]
                _UpperCamelCase     :       Optional[int]  						=  state_dict[F"blocks.{depth}.attn.proj.bias"]
  
                _UpperCamelCase     :       Optional[int]  						=  state_dict[F"blocks.{depth}.mlp.fc1.weight"]
                _UpperCamelCase     :       Optional[Any]  						=  state_dict[F"blocks.{depth}.mlp.fc1.bias"]
                _UpperCamelCase     :       Union[str, Any]  						=  state_dict[F"blocks.{depth}.mlp.fc2.weight"]
                _UpperCamelCase     :       str  						=  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     :       Optional[Any]  						=  state_dict['final_layer.adaLN_modulation.1.weight']
         _UpperCamelCase     :       List[Any]  						=  state_dict['final_layer.adaLN_modulation.1.bias']
         _UpperCamelCase     :       List[str]  						=  state_dict['final_layer.linear.weight']
         _UpperCamelCase     :       Any  						=  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     :       List[str]  						=  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=lowerCamelCase__		,						num_attention_heads=16		,						activation_fn='gelu-approximate'		,						num_embeds_ada_norm=1000		,						norm_type='ada_norm_zero'		,						norm_elementwise_affine=lowerCamelCase__		,						)
         transformer.load_state_dict(lowerCamelCase__		,						strict=lowerCamelCase__				)
  
         _UpperCamelCase     :       List[str]  						=  DDIMScheduler(
             num_train_timesteps=1000		,						beta_schedule='linear'		,						prediction_type='epsilon'		,						clip_sample=lowerCamelCase__		,						)
  
         _UpperCamelCase     :       Optional[Any]  						=  AutoencoderKL.from_pretrained(args.vae_model				)
  
         _UpperCamelCase     :       Any  						=  DiTPipeline(transformer=lowerCamelCase__		,						vae=lowerCamelCase__		,						scheduler=lowerCamelCase__				)
  
         if args.save:
                pipeline.save_pretrained(args.checkpoint_path				)
  
  
  if __name__ == "__main__":
   UpperCAmelCase					=				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.'''
   )
  
   UpperCAmelCase					=				parser.parse_args()
   main(args)
  
  
  
  
style_context: from ..utils import requires_backends
  
  
  UpperCAmelCase					=				None
  
  
  
  
  class    __lowerCAmelCase  :
  
  
  
   '''simple docstring'''
  
   def __init__(			self       :		Optional[int]       ,			*lowerCamelCase       :		Dict       ,			**lowerCamelCase       :		int  ) ->							Tuple:
          requires_backends(self       ,			['detectron2']  )
  
   @classmethod
   def 					__snake_case					(			cls       :		Optional[Any]       ,			*lowerCamelCase       :		Optional[int]       ,			**lowerCamelCase       :		Tuple  ) ->							List[str]:
          requires_backends(cls       ,			['detectron2']  )
  
  
  
  