code: 
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  import argparse
  import os
  
  import torch
  from torchvision.datasets.utils import download_url
  
  from diffusers import AutoencoderKL, DDIMScheduler, DiTPipeline, TransformeraDModel
  
  
  lowercase__			=	{5_1_2: '''DiT-XL-2-512x512.pt''', 2_5_6: '''DiT-XL-2-256x256.pt'''}
  
  
  def 				UpperCamelCase	(  snake_case   ):
  
  
  
  
     '''simple docstring'''
  
     SCREAMING_SNAKE_CASE__			:				str       						= f"""pretrained_models/{model_name}"""
     if not os.path.isfile(snake_case   ):
        os.makedirs('''pretrained_models'''	,     exist_ok=snake_case   )
        SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= f"""https://dl.fbaipublicfiles.com/DiT/models/{model_name}"""
        download_url(snake_case	,     '''pretrained_models'''   )
     SCREAMING_SNAKE_CASE__			:				str       						= torch.load(snake_case	,     map_location=lambda snake_case	,     snake_case   : storage   )
     return model
  
  
  def 				UpperCamelCase	(  snake_case   ):
  
  
  
  
     '''simple docstring'''
  
     SCREAMING_SNAKE_CASE__			:				int       						= download_model(pretrained_models[args.image_size]   )
  
     SCREAMING_SNAKE_CASE__			:				Any       						= state_dict["""x_embedder.proj.weight"""]
     SCREAMING_SNAKE_CASE__			:				Any       						= 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   ):
        SCREAMING_SNAKE_CASE__			:				List[str]       						= state_dict[
            """t_embedder.mlp.0.weight"""
        ]
        SCREAMING_SNAKE_CASE__			:				Any       						= state_dict[
            """t_embedder.mlp.0.bias"""
        ]
        SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= state_dict[
            """t_embedder.mlp.2.weight"""
        ]
        SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= state_dict[
            """t_embedder.mlp.2.bias"""
        ]
        SCREAMING_SNAKE_CASE__			:				List[Any]       						= state_dict[
            """y_embedder.embedding_table.weight"""
        ]
  
        SCREAMING_SNAKE_CASE__			:				Optional[int]       						= state_dict[
            f"""blocks.{depth}.adaLN_modulation.1.weight"""
        ]
        SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= state_dict[
            f"""blocks.{depth}.adaLN_modulation.1.bias"""
        ]
  
        SCREAMING_SNAKE_CASE__			:				List[str]       						= torch.chunk(state_dict[f"""blocks.{depth}.attn.qkv.weight"""]	,     3	,     dim=0   )
        SCREAMING_SNAKE_CASE__			:				Any       						= torch.chunk(state_dict[f"""blocks.{depth}.attn.qkv.bias"""]	,     3	,     dim=0   )
  
        SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= q
        SCREAMING_SNAKE_CASE__			:				List[str]       						= q_bias
        SCREAMING_SNAKE_CASE__			:				Optional[int]       						= k
        SCREAMING_SNAKE_CASE__			:				str       						= k_bias
        SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= v
        SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= v_bias
  
        SCREAMING_SNAKE_CASE__			:				Any       						= state_dict[
            f"""blocks.{depth}.attn.proj.weight"""
        ]
        SCREAMING_SNAKE_CASE__			:				str       						= state_dict[f"""blocks.{depth}.attn.proj.bias"""]
  
        SCREAMING_SNAKE_CASE__			:				List[Any]       						= state_dict[f"""blocks.{depth}.mlp.fc1.weight"""]
        SCREAMING_SNAKE_CASE__			:				str       						= state_dict[f"""blocks.{depth}.mlp.fc1.bias"""]
        SCREAMING_SNAKE_CASE__			:				int       						= state_dict[f"""blocks.{depth}.mlp.fc2.weight"""]
        SCREAMING_SNAKE_CASE__			:				Dict       						= 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'''   )
  
     SCREAMING_SNAKE_CASE__			:				int       						= state_dict["""final_layer.adaLN_modulation.1.weight"""]
     SCREAMING_SNAKE_CASE__			:				List[Any]       						= state_dict["""final_layer.adaLN_modulation.1.bias"""]
     SCREAMING_SNAKE_CASE__			:				Dict       						= state_dict["""final_layer.linear.weight"""]
     SCREAMING_SNAKE_CASE__			:				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
     SCREAMING_SNAKE_CASE__			:				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=snake_case	,     num_attention_heads=16	,     activation_fn='''gelu-approximate'''	,     num_embeds_ada_norm=10_00	,     norm_type='''ada_norm_zero'''	,     norm_elementwise_affine=snake_case	,     )
     transformer.load_state_dict(snake_case	,     strict=snake_case   )
  
     SCREAMING_SNAKE_CASE__			:				Any       						= DDIMScheduler(
         num_train_timesteps=10_00	,     beta_schedule='''linear'''	,     prediction_type='''epsilon'''	,     clip_sample=snake_case	,     )
  
     SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= AutoencoderKL.from_pretrained(args.vae_model   )
  
     SCREAMING_SNAKE_CASE__			:				Dict       						= DiTPipeline(transformer=snake_case	,     vae=snake_case	,     scheduler=snake_case   )
  
     if args.save:
        pipeline.save_pretrained(args.checkpoint_path   )
  
  
  if __name__ == "__main__":
         lowercase__			=	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.'''
         )
  
         lowercase__			=	parser.parse_args()
         main(args)
  
  
  
style_context: 
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  import argparse
  import json
  import re
  import string
  import sys
  from collections import Counter
  
  
  def 				UpperCamelCase	(  snake_case   ):
  
  
  
  
     '''simple docstring'''
  
     def remove_articles(snake_case   ):
        return re.sub(R'''\b(a|an|the)\b'''	,     ''' '''	,     snake_case   )
  
     def white_space_fix(snake_case   ):
        return " ".join(text.split()   )
  
     def remove_punc(snake_case   ):
        SCREAMING_SNAKE_CASE__			:				Optional[int]       						= set(string.punctuation   )
        return "".join(ch for ch in text if ch not in exclude   )
  
     def lower(snake_case   ):
        return text.lower()
  
     return white_space_fix(remove_articles(remove_punc(lower(snake_case   )   )   )   )
  
  
  def 				UpperCamelCase	(  snake_case	,     snake_case   ):
  
  
  
  
     '''simple docstring'''
  
     SCREAMING_SNAKE_CASE__			:				Tuple       						= normalize_answer(snake_case   ).split()
     SCREAMING_SNAKE_CASE__			:				List[Any]       						= normalize_answer(snake_case   ).split()
     SCREAMING_SNAKE_CASE__			:				Dict       						= Counter(snake_case   ) & Counter(snake_case   )
     SCREAMING_SNAKE_CASE__			:				int       						= sum(common.values()   )
     if num_same == 0:
        return 0
     SCREAMING_SNAKE_CASE__			:				Tuple       						= 1.0 * num_same / len(snake_case   )
     SCREAMING_SNAKE_CASE__			:				Tuple       						= 1.0 * num_same / len(snake_case   )
     SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= (2 * precision * recall) / (precision + recall)
     return fa
  
  
  def 				UpperCamelCase	(  snake_case	,     snake_case   ):
  
  
  
  
     '''simple docstring'''
  
     return normalize_answer(snake_case   ) == normalize_answer(snake_case   )
  
  
  def 				UpperCamelCase	(  snake_case	,     snake_case	,     snake_case   ):
  
  
  
  
     '''simple docstring'''
  
     SCREAMING_SNAKE_CASE__			:				Any       						= []
     for ground_truth in ground_truths:
        SCREAMING_SNAKE_CASE__			:				List[Any]       						= metric_fn(snake_case	,     snake_case   )
        scores_for_ground_truths.append(snake_case   )
     return max(snake_case   )
  
  
  def 				UpperCamelCase	(  snake_case	,     snake_case   ):
  
  
  
  
     '''simple docstring'''
  
     SCREAMING_SNAKE_CASE__			:				str       						= 0
     SCREAMING_SNAKE_CASE__			:				Optional[int]       						= []
     for passage in dataset:
        for qa in passage["qas"]:
           total += 1
           if qa["id"] not in predictions:
              SCREAMING_SNAKE_CASE__			:				Any       						= f"""Unanswered question {qa["id"]} will receive score 0."""
              print(snake_case	,     file=sys.stderr   )
              continue
  
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= [x['''text'''] for x in qa['''answers''']]
           SCREAMING_SNAKE_CASE__			:				Optional[int]       						= predictions[qa['''id''']]
  
           SCREAMING_SNAKE_CASE__			:				List[str]       						= metric_max_over_ground_truths(snake_case	,     snake_case	,     snake_case   )
           if int(_exact_match   ) == 1:
              correct_ids.append(qa['''id''']   )
           exact_match += _exact_match
  
           fa += metric_max_over_ground_truths(snake_case	,     snake_case	,     snake_case   )
  
     SCREAMING_SNAKE_CASE__			:				int       						= exact_match / total
     SCREAMING_SNAKE_CASE__			:				Optional[int]       						= fa / total
  
     return {"exact_match": exact_match, "f1": fa}, correct_ids
  
  
  if __name__ == "__main__":
         lowercase__			=	'''1.0'''
         lowercase__			=	argparse.ArgumentParser('''Official evaluation script for ReCoRD v1.0.''')
         parser.add_argument('''data_file''', help='''The dataset file in JSON format.''')
         parser.add_argument('''pred_file''', help='''The model prediction file in JSON format.''')
         parser.add_argument('''--output_correct_ids''', action='''store_true''', help='''Output the correctly answered query IDs.''')
         lowercase__			=	parser.parse_args()
  
         with open(args.data_file) as data_file:
                lowercase__			=	json.load(data_file)
                if dataset_json["version"] != expected_version:
                       print(
                           F"Evaluation expects v-{expected_version}, but got dataset with v-{dataset_json['version']}",
                           file=sys.stderr,
                       )
                lowercase__			=	dataset_json['''data''']
  
         with open(args.pred_file) as pred_file:
                lowercase__			=	json.load(pred_file)
  
         lowercase__	,     lowercase__			=	evaluate(dataset, predictions)
  
         if args.output_correct_ids:
                print(F"Output {len(correct_ids)} correctly answered question IDs.")
                with open('''correct_ids.json''', '''w''') as f:
                       json.dump(correct_ids, f)
  
  