code: 
  
  
  import argparse
  import os
  
  import torch
  from torchvision.datasets.utils import download_url
  
  from diffusers import AutoencoderKL, DDIMScheduler, DiTPipeline, TransformeraDModel
  
  
  UpperCamelCase__				       =			{512: 'DiT-XL-2-512x512.pt', 256: 'DiT-XL-2-256x256.pt'}
  
  def   UpperCamelCase__   (    UpperCAmelCase_			)						->							Union[str, Any]:
  
  
  
  
         '''simple docstring'''
  
  
  
  
  
  
         _lowercase					:				List[str]           =			F'pretrained_models/{model_name}'
         if not os.path.isfile(UpperCAmelCase_			):
                os.makedirs('''pretrained_models'''    ,     exist_ok=UpperCAmelCase_			)
                _lowercase					:				Optional[int]           =			F'https://dl.fbaipublicfiles.com/DiT/models/{model_name}'
                download_url(UpperCAmelCase_    ,     '''pretrained_models'''			)
         _lowercase					:				int           =			torch.load(UpperCAmelCase_    ,     map_location=lambda UpperCAmelCase_    ,     UpperCAmelCase_			: storage			)
         return model
  
  def   UpperCamelCase__   (    UpperCAmelCase_			)						->							Optional[int]:
  
  
  
  
         '''simple docstring'''
  
  
  
  
  
  
         _lowercase					:				Dict           =			download_model(pretrained_models[args.image_size]			)
  
         _lowercase					:				List[str]           =			state_dict['''x_embedder.proj.weight''']
         _lowercase					:				str           =			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			):
                _lowercase					:				Dict           =			state_dict[
                    '''t_embedder.mlp.0.weight'''
                ]
                _lowercase					:				Any           =			state_dict[
                    '''t_embedder.mlp.0.bias'''
                ]
                _lowercase					:				int           =			state_dict[
                    '''t_embedder.mlp.2.weight'''
                ]
                _lowercase					:				Optional[int]           =			state_dict[
                    '''t_embedder.mlp.2.bias'''
                ]
                _lowercase					:				Any           =			state_dict[
                    '''y_embedder.embedding_table.weight'''
                ]
  
                _lowercase					:				str           =			state_dict[
                    F'blocks.{depth}.adaLN_modulation.1.weight'
                ]
                _lowercase					:				Optional[int]           =			state_dict[
                    F'blocks.{depth}.adaLN_modulation.1.bias'
                ]
  
                _lowercase       ,	_lowercase       ,	_lowercase					:				Optional[Any]           =			torch.chunk(state_dict[F'blocks.{depth}.attn.qkv.weight']    ,     3    ,     dim=0			)
                _lowercase       ,	_lowercase       ,	_lowercase					:				List[str]           =			torch.chunk(state_dict[F'blocks.{depth}.attn.qkv.bias']    ,     3    ,     dim=0			)
  
                _lowercase					:				Tuple           =			q
                _lowercase					:				List[str]           =			q_bias
                _lowercase					:				List[Any]           =			k
                _lowercase					:				Optional[Any]           =			k_bias
                _lowercase					:				List[Any]           =			v
                _lowercase					:				Union[str, Any]           =			v_bias
  
                _lowercase					:				Optional[int]           =			state_dict[
                    F'blocks.{depth}.attn.proj.weight'
                ]
                _lowercase					:				Union[str, Any]           =			state_dict[F'blocks.{depth}.attn.proj.bias']
  
                _lowercase					:				List[Any]           =			state_dict[F'blocks.{depth}.mlp.fc1.weight']
                _lowercase					:				str           =			state_dict[F'blocks.{depth}.mlp.fc1.bias']
                _lowercase					:				int           =			state_dict[F'blocks.{depth}.mlp.fc2.weight']
                _lowercase					:				Union[str, Any]           =			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'''			)
  
         _lowercase					:				Union[str, Any]           =			state_dict['''final_layer.adaLN_modulation.1.weight''']
         _lowercase					:				Dict           =			state_dict['''final_layer.adaLN_modulation.1.bias''']
         _lowercase					:				Dict           =			state_dict['''final_layer.linear.weight''']
         _lowercase					:				str           =			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
         _lowercase					:				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=UpperCAmelCase_    ,     num_attention_heads=16    ,     activation_fn='''gelu-approximate'''    ,     num_embeds_ada_norm=1000    ,     norm_type='''ada_norm_zero'''    ,     norm_elementwise_affine=UpperCAmelCase_    ,     )
         transformer.load_state_dict(UpperCAmelCase_    ,     strict=UpperCAmelCase_			)
  
         _lowercase					:				int           =			DDIMScheduler(
             num_train_timesteps=1000    ,     beta_schedule='''linear'''    ,     prediction_type='''epsilon'''    ,     clip_sample=UpperCAmelCase_    ,     )
  
         _lowercase					:				int           =			AutoencoderKL.from_pretrained(args.vae_model			)
  
         _lowercase					:				int           =			DiTPipeline(transformer=UpperCAmelCase_    ,     vae=UpperCAmelCase_    ,     scheduler=UpperCAmelCase_			)
  
         if args.save:
                pipeline.save_pretrained(args.checkpoint_path			)
  
  
  if __name__ == "__main__":
     UpperCamelCase__				       =			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.'
     )
  
     UpperCamelCase__				       =			parser.parse_args()
     main(args)
  
  
  
style_context: 
  
  
  import torch
  import torch.nn as nn
  from transformers.modeling_utils import ModuleUtilsMixin
  from transformers.models.ta.modeling_ta import (
      TaBlock,
      TaConfig,
      TaLayerNorm,
  )
  
  from ...configuration_utils import ConfigMixin, register_to_config
  from ...models import ModelMixin
  
  class 						UpperCAmelCase__   (      A_      ,						A_      ,						A_		):
  
  
  
       '''simple docstring'''
  
  
  
  
       @register_to_config
       def __init__( self       :       Dict	,      UpperCamelCase       :       int	,      UpperCamelCase       :       int	,      UpperCamelCase       :       int	,      UpperCamelCase       :       float	,      UpperCamelCase       :       int	,      UpperCamelCase       :       int	,      UpperCamelCase       :       int	,      UpperCamelCase       :       int	,      UpperCamelCase       :       str	,      UpperCamelCase       :       bool = False	,      ):
  
  
  
  
  
              """simple docstring"""
  
  
  
              super().__init__()
  
              _lowercase					:				Any           =			nn.Linear(UpperCamelCase	,      UpperCamelCase	,      bias=UpperCamelCase		)
  
              _lowercase					:				List[Any]           =			nn.Embedding(UpperCamelCase	,      UpperCamelCase		)
              _lowercase					:				Any           =			False
  
              _lowercase					:				Tuple           =			nn.Dropout(p=UpperCamelCase		)
  
              _lowercase					:				Any           =			TaConfig(
                  d_model=UpperCamelCase	,      num_heads=UpperCamelCase	,      d_kv=UpperCamelCase	,      d_ff=UpperCamelCase	,      feed_forward_proj=UpperCamelCase	,      dropout_rate=UpperCamelCase	,      is_decoder=UpperCamelCase	,      is_encoder_decoder=UpperCamelCase	,      )
              _lowercase					:				Any           =			nn.ModuleList()
              for lyr_num in range(UpperCamelCase		):
                     _lowercase					:				Tuple           =			TaBlock(UpperCamelCase		)
                     self.encoders.append(UpperCamelCase		)
  
              _lowercase					:				List[Any]           =			TaLayerNorm(UpperCamelCase		)
              _lowercase					:				Optional[Any]           =			nn.Dropout(p=UpperCamelCase		)
  
  
  
  
       def   lowerCAmelCase_   ( self       :       int	,      UpperCamelCase       :       Optional[int]	,      UpperCamelCase       :       List[Any]		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              _lowercase					:				Optional[int]           =			self.input_proj(UpperCamelCase		)
  
              # terminal relative positional encodings
              _lowercase					:				Optional[int]           =			encoder_inputs.shape[1]
              _lowercase					:				Optional[int]           =			torch.arange(UpperCamelCase	,      device=encoder_inputs.device		)
  
              _lowercase					:				Any           =			encoder_inputs_mask.sum(-1		)
              _lowercase					:				int           =			torch.roll(input_positions.unsqueeze(0		)	,      tuple(seq_lens.tolist()		)	,      dims=0		)
              x += self.position_encoding(UpperCamelCase		)
  
              _lowercase					:				Optional[int]           =			self.dropout_pre(UpperCamelCase		)
  
              # inverted the attention mask
              _lowercase					:				Optional[int]           =			encoder_inputs.size()
              _lowercase					:				List[Any]           =			self.get_extended_attention_mask(UpperCamelCase	,      UpperCamelCase		)
  
              for lyr in self.encoders:
                     _lowercase					:				Optional[int]           =			lyr(UpperCamelCase	,      UpperCamelCase		)[0]
              _lowercase					:				List[str]           =			self.layer_norm(UpperCamelCase		)
  
              return self.dropout_post(UpperCamelCase		), encoder_inputs_mask