code: 
  
  
  import argparse
  import os
  
  import torch
  from torchvision.datasets.utils import download_url
  
  from diffusers import AutoencoderKL, DDIMScheduler, DiTPipeline, TransformeraDModel
  
  
  lowerCAmelCase					 =	{5_1_2: '''DiT-XL-2-512x512.pt''', 2_5_6: '''DiT-XL-2-256x256.pt'''}
  
  
  
  
  
  
  
  def  _lowerCamelCase(			lowercase__			)		->			Dict:
  
  						'''simple docstring'''
  
  
  
  
  
  
  
  						__lowercase=    F'pretrained_models/{model_name}'
  						if not os.path.isfile(lowercase__			):
  												os.makedirs('pretrained_models'     ,				exist_ok=lowercase__			)
  												__lowercase=    F'https://dl.fbaipublicfiles.com/DiT/models/{model_name}'
  												download_url(lowercase__     ,				'pretrained_models'			)
  						__lowercase=    torch.load(lowercase__     ,				map_location=lambda lowercase__     ,				lowercase__			: storage			)
  						return model
  
  
  
  
  
  
  
  def  _lowerCamelCase(			lowercase__			)		->			int:
  
  						'''simple docstring'''
  
  
  
  
  
  
  
  						__lowercase=    download_model(pretrained_models[args.image_size]			)
  
  						__lowercase=    state_dict['x_embedder.proj.weight']
  						__lowercase=    state_dict['x_embedder.proj.bias']
  						state_dict.pop('x_embedder.proj.weight'			)
  						state_dict.pop('x_embedder.proj.bias'			)
  
  						for depth in range(2_8			):
  												__lowercase=    state_dict[
  												    't_embedder.mlp.0.weight'
  												]
  												__lowercase=    state_dict[
  												    't_embedder.mlp.0.bias'
  												]
  												__lowercase=    state_dict[
  												    't_embedder.mlp.2.weight'
  												]
  												__lowercase=    state_dict[
  												    't_embedder.mlp.2.bias'
  												]
  												__lowercase=    state_dict[
  												    'y_embedder.embedding_table.weight'
  												]
  
  												__lowercase=    state_dict[
  												    F'blocks.{depth}.adaLN_modulation.1.weight'
  												]
  												__lowercase=    state_dict[
  												    F'blocks.{depth}.adaLN_modulation.1.bias'
  												]
  
  												__lowercase,							__lowercase,							__lowercase=    torch.chunk(state_dict[F'blocks.{depth}.attn.qkv.weight']     ,				3     ,				dim=0			)
  												__lowercase,							__lowercase,							__lowercase=    torch.chunk(state_dict[F'blocks.{depth}.attn.qkv.bias']     ,				3     ,				dim=0			)
  
  												__lowercase=    q
  												__lowercase=    q_bias
  												__lowercase=    k
  												__lowercase=    k_bias
  												__lowercase=    v
  												__lowercase=    v_bias
  
  												__lowercase=    state_dict[
  												    F'blocks.{depth}.attn.proj.weight'
  												]
  												__lowercase=    state_dict[F'blocks.{depth}.attn.proj.bias']
  
  												__lowercase=    state_dict[F'blocks.{depth}.mlp.fc1.weight']
  												__lowercase=    state_dict[F'blocks.{depth}.mlp.fc1.bias']
  												__lowercase=    state_dict[F'blocks.{depth}.mlp.fc2.weight']
  												__lowercase=    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=    state_dict['final_layer.adaLN_modulation.1.weight']
  						__lowercase=    state_dict['final_layer.adaLN_modulation.1.bias']
  						__lowercase=    state_dict['final_layer.linear.weight']
  						__lowercase=    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=    TransformeraDModel(
  						    sample_size=args.image_size // 8     ,				num_layers=2_8     ,				attention_head_dim=7_2     ,				in_channels=4     ,				out_channels=8     ,				patch_size=2     ,				attention_bias=lowercase__     ,				num_attention_heads=1_6     ,				activation_fn='gelu-approximate'     ,				num_embeds_ada_norm=1_0_0_0     ,				norm_type='ada_norm_zero'     ,				norm_elementwise_affine=lowercase__     ,				)
  						transformer.load_state_dict(lowercase__     ,				strict=lowercase__			)
  
  						__lowercase=    DDIMScheduler(
  						    num_train_timesteps=1_0_0_0     ,				beta_schedule='linear'     ,				prediction_type='epsilon'     ,				clip_sample=lowercase__     ,				)
  
  						__lowercase=    AutoencoderKL.from_pretrained(args.vae_model			)
  
  						__lowercase=    DiTPipeline(transformer=lowercase__     ,				vae=lowercase__     ,				scheduler=lowercase__			)
  
  						if args.save:
  												pipeline.save_pretrained(args.checkpoint_path			)
  
  
  if __name__ == "__main__":
  	lowerCAmelCase					 =	argparse.ArgumentParser()
  
  	parser.add_argument(
  	    '''--image_size''',
  	    default=2_5_6,
  	    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					 =	parser.parse_args()
  	main(args)
  
  
  
  
  
  
  
style_context: 
  
  
  from dataclasses import dataclass
  from typing import List, Optional, Union
  
  import numpy as np
  import PIL
  from PIL import Image
  
  from ...utils import BaseOutput, is_torch_available, is_transformers_available
  
  
  
  
  
  @dataclass
  # Copied from diffusers.pipelines.stable_diffusion.__init__.StableDiffusionPipelineOutput with Stable->Alt
  class    A					(     A_				):
  							UpperCamelCase_     :							Union[List[PIL.Image.Image], np.ndarray]
  							UpperCamelCase_     :							Optional[List[bool]]
  
  
  if is_transformers_available() and is_torch_available():
  	from .modeling_roberta_series import RobertaSeriesModelWithTransformation
  	from .pipeline_alt_diffusion import AltDiffusionPipeline
  	from .pipeline_alt_diffusion_imgaimg import AltDiffusionImgaImgPipeline
  
  
  
  
  
  
  