code: import argparse
  import os
  
  import torch
  from torchvision.datasets.utils import download_url
  
  from diffusers import AutoencoderKL, DDIMScheduler, DiTPipeline, TransformeraDModel
  
  
  _SCREAMING_SNAKE_CASE   						=    {512: """DiT-XL-2-512x512.pt""", 256: """DiT-XL-2-256x256.pt"""}
  def 				__lowercase	(						lowerCamelCase__					)				->Union[str, Any]:
  
    '''simple docstring'''
  
  
  
  
    a__     		=     f"pretrained_models/{model_name}"
    if not os.path.isfile(lowerCamelCase__					):
      os.makedirs("pretrained_models" ,				exist_ok=lowerCamelCase__					)
      a__     		=     f"https://dl.fbaipublicfiles.com/DiT/models/{model_name}"
      download_url(lowerCamelCase__ ,				"pretrained_models"					)
    a__     		=     torch.load(lowerCamelCase__ ,				map_location=lambda lowerCamelCase__ ,				lowerCamelCase__					: storage					)
    return model
  def 				__lowercase	(						lowerCamelCase__					)				->str:
  
    '''simple docstring'''
  
  
  
  
    a__     		=     download_model(pretrained_models[args.image_size]					)
  
    a__     		=     state_dict["x_embedder.proj.weight"]
    a__     		=     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					):
      a__     		=     state_dict[
          "t_embedder.mlp.0.weight"
      ]
      a__     		=     state_dict[
          "t_embedder.mlp.0.bias"
      ]
      a__     		=     state_dict[
          "t_embedder.mlp.2.weight"
      ]
      a__     		=     state_dict[
          "t_embedder.mlp.2.bias"
      ]
      a__     		=     state_dict[
          "y_embedder.embedding_table.weight"
      ]
  
      a__     		=     state_dict[
          f"blocks.{depth}.adaLN_modulation.1.weight"
      ]
      a__     		=     state_dict[
          f"blocks.{depth}.adaLN_modulation.1.bias"
      ]
  
      a__		,a__		,a__     		=     torch.chunk(state_dict[f"blocks.{depth}.attn.qkv.weight"] ,				3 ,				dim=0					)
      a__		,a__		,a__     		=     torch.chunk(state_dict[f"blocks.{depth}.attn.qkv.bias"] ,				3 ,				dim=0					)
  
      a__     		=     q
      a__     		=     q_bias
      a__     		=     k
      a__     		=     k_bias
      a__     		=     v
      a__     		=     v_bias
  
      a__     		=     state_dict[
          f"blocks.{depth}.attn.proj.weight"
      ]
      a__     		=     state_dict[f"blocks.{depth}.attn.proj.bias"]
  
      a__     		=     state_dict[f"blocks.{depth}.mlp.fc1.weight"]
      a__     		=     state_dict[f"blocks.{depth}.mlp.fc1.bias"]
      a__     		=     state_dict[f"blocks.{depth}.mlp.fc2.weight"]
      a__     		=     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"					)
  
    a__     		=     state_dict["final_layer.adaLN_modulation.1.weight"]
    a__     		=     state_dict["final_layer.adaLN_modulation.1.bias"]
    a__     		=     state_dict["final_layer.linear.weight"]
    a__     		=     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
    a__     		=     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=10_00 ,				norm_type="ada_norm_zero" ,				norm_elementwise_affine=lowerCamelCase__ ,				)
    transformer.load_state_dict(lowerCamelCase__ ,				strict=lowerCamelCase__					)
  
    a__     		=     DDIMScheduler(
        num_train_timesteps=10_00 ,				beta_schedule="linear" ,				prediction_type="epsilon" ,				clip_sample=lowerCamelCase__ ,				)
  
    a__     		=     AutoencoderKL.from_pretrained(args.vae_model					)
  
    a__     		=     DiTPipeline(transformer=lowerCamelCase__ ,				vae=lowerCamelCase__ ,				scheduler=lowerCamelCase__					)
  
    if args.save:
      pipeline.save_pretrained(args.checkpoint_path					)
  
  
  if __name__ == "__main__":
       _SCREAMING_SNAKE_CASE   						=    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."""
       )
  
       _SCREAMING_SNAKE_CASE   						=    parser.parse_args()
       main(args)
  
  
style_context: from unittest.mock import patch
  
  import datasets
  from datasets import Dataset
  def 				__lowercase	(						)				->Union[str, Any]:
  
    '''simple docstring'''
  
  
  
  
    a__     		=     Dataset.from_dict({"col_1": [3, 2, 0, 1]}					)
  
    with patch("tqdm.auto.tqdm"					) as mock_tqdm:
      datasets.disable_progress_bar()
      dset.map(lambda lowerCamelCase__					: {"col_2": x["col_1"] + 1}					)
      mock_tqdm.assert_not_called()
  
      mock_tqdm.reset_mock()
  
      datasets.enable_progress_bar()
      dset.map(lambda lowerCamelCase__					: {"col_2": x["col_1"] + 1}					)
      mock_tqdm.assert_called()
  
  