code: 
  
  
  
  
  
  
  """simple docstring"""
  
  
  
  
  
  
  import argparse
  import os
  
  import torch
  from torchvision.datasets.utils import download_url
  
  from diffusers import AutoencoderKL, DDIMScheduler, DiTPipeline, TransformeraDModel
  
  
  A_			  =    {512: "DiT-XL-2-512x512.pt", 256: "DiT-XL-2-256x256.pt"}
  
  
  
  
  def 						_UpperCamelCase			(  A			):
  			UpperCamelCase_     =f"""pretrained_models/{model_name}"""
  			if not os.path.isfile(A			):
  						os.makedirs("pretrained_models"    ,       exist_ok=A			)
  						UpperCamelCase_     =f"""https://dl.fbaipublicfiles.com/DiT/models/{model_name}"""
  						download_url(A    ,       "pretrained_models"			)
  			UpperCamelCase_     =torch.load(A    ,       map_location=lambda A    ,       A			: storage			)
  			return model
  
  
  
  
  def 						_UpperCamelCase			(  A			):
  			UpperCamelCase_     =download_model(pretrained_models[args.image_size]			)
  
  			UpperCamelCase_     =state_dict["x_embedder.proj.weight"]
  			UpperCamelCase_     =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_     =state_dict[
  						    "t_embedder.mlp.0.weight"
  						]
  						UpperCamelCase_     =state_dict[
  						    "t_embedder.mlp.0.bias"
  						]
  						UpperCamelCase_     =state_dict[
  						    "t_embedder.mlp.2.weight"
  						]
  						UpperCamelCase_     =state_dict[
  						    "t_embedder.mlp.2.bias"
  						]
  						UpperCamelCase_     =state_dict[
  						    "y_embedder.embedding_table.weight"
  						]
  
  						UpperCamelCase_     =state_dict[
  						    f"""blocks.{depth}.adaLN_modulation.1.weight"""
  						]
  						UpperCamelCase_     =state_dict[
  						    f"""blocks.{depth}.adaLN_modulation.1.bias"""
  						]
  
  						UpperCamelCase_    ,							UpperCamelCase_    ,							UpperCamelCase_     =torch.chunk(state_dict[f"""blocks.{depth}.attn.qkv.weight"""]    ,       3    ,       dim=0			)
  						UpperCamelCase_    ,							UpperCamelCase_    ,							UpperCamelCase_     =torch.chunk(state_dict[f"""blocks.{depth}.attn.qkv.bias"""]    ,       3    ,       dim=0			)
  
  						UpperCamelCase_     =q
  						UpperCamelCase_     =q_bias
  						UpperCamelCase_     =k
  						UpperCamelCase_     =k_bias
  						UpperCamelCase_     =v
  						UpperCamelCase_     =v_bias
  
  						UpperCamelCase_     =state_dict[
  						    f"""blocks.{depth}.attn.proj.weight"""
  						]
  						UpperCamelCase_     =state_dict[f"""blocks.{depth}.attn.proj.bias"""]
  
  						UpperCamelCase_     =state_dict[f"""blocks.{depth}.mlp.fc1.weight"""]
  						UpperCamelCase_     =state_dict[f"""blocks.{depth}.mlp.fc1.bias"""]
  						UpperCamelCase_     =state_dict[f"""blocks.{depth}.mlp.fc2.weight"""]
  						UpperCamelCase_     =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_     =state_dict["final_layer.adaLN_modulation.1.weight"]
  			UpperCamelCase_     =state_dict["final_layer.adaLN_modulation.1.bias"]
  			UpperCamelCase_     =state_dict["final_layer.linear.weight"]
  			UpperCamelCase_     =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_     =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=1_000    ,       norm_type="ada_norm_zero"    ,       norm_elementwise_affine=A    ,       )
  			transformer.load_state_dict(A    ,       strict=A			)
  
  			UpperCamelCase_     =DDIMScheduler(
  			    num_train_timesteps=1_000    ,       beta_schedule="linear"    ,       prediction_type="epsilon"    ,       clip_sample=A    ,       )
  
  			UpperCamelCase_     =AutoencoderKL.from_pretrained(args.vae_model			)
  
  			UpperCamelCase_     =DiTPipeline(transformer=A    ,       vae=A    ,       scheduler=A			)
  
  			if args.save:
  						pipeline.save_pretrained(args.checkpoint_path			)
  
  
  if __name__ == "__main__":
  				A_			  =    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."
  				)
  
  				A_			  =    parser.parse_args()
  				main(args)
  
style_context: 
  
  
  
  
  
  
  """simple docstring"""
  
  
  
  
  
  
  from .hash_table import HashTable
  from .number_theory.prime_numbers import is_prime, next_prime
  class 						__lowerCAmelCase   (			UpperCAmelCase       ):
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    def __init__(      self:		List[Any]				,			*UpperCamelCase_:		Dict				,			**UpperCamelCase_:		Optional[int]					):
       super().__init__(*UpperCamelCase_				,			**UpperCamelCase_					)
    def 					UpperCamelCase__   (      self:		Any				,			UpperCamelCase_:		Optional[int]				,			UpperCamelCase_:		Optional[int]					):
       UpperCamelCase_     =(
           next_prime(value % self.size_table					)
           if not is_prime(value % self.size_table					)
           else value % self.size_table
       )  # gt = bigger than
       return next_prime_gt - (data % next_prime_gt)
    def 					UpperCamelCase__   (      self:		str				,			UpperCamelCase_:		List[str]				,			UpperCamelCase_:		str				,			UpperCamelCase_:		Tuple					):
       return (increment * self.__hash_function_a(UpperCamelCase_				,			UpperCamelCase_					)) % self.size_table
  
  
  
  
  
    def 					UpperCamelCase__   (      self:		str				,			UpperCamelCase_:		int				,			UpperCamelCase_:		str=None					):
       UpperCamelCase_     =1
       UpperCamelCase_     =self.hash_function(UpperCamelCase_					)
  
       while self.values[new_key] is not None and self.values[new_key] != key:
          UpperCamelCase_     =(
              self.__hash_double_function(UpperCamelCase_				,			UpperCamelCase_				,			UpperCamelCase_					)
              if self.balanced_factor() >= self.lim_charge
              else None
          )
          if new_key is None:
             break
          else:
             i += 1
  
       return new_key
  