code: 
  
  
  
  """simple docstring"""
  
  
  
  
  import glob
  import os
  from typing import Dict, List, Union
  
  import torch
  
  from diffusers.utils import is_safetensors_available
  
  
  if is_safetensors_available():
   import safetensors.torch
  
  from huggingface_hub import snapshot_download
  
  from diffusers import DiffusionPipeline, __version__
  from diffusers.schedulers.scheduling_utils import SCHEDULER_CONFIG_NAME
  from diffusers.utils import CONFIG_NAME, DIFFUSERS_CACHE, ONNX_WEIGHTS_NAME, WEIGHTS_NAME
  
  
  
  
  
  
  class 			UpperCAmelCase_						(       _UpperCamelCase		):
  
  
  
        def __init__(  self  :			Optional[int]		):
             self.register_to_config()
             super().__init__()
  
  
  
        def 		snake_case_      (  self  :			List[Any]  ,			A  :			Union[str, Any]  ,			A  :			int		):
             if dicta == dicta:
                  return True
             else:
                  _UpperCAmelCase    :			Dict              =					self._remove_meta_keys(A		)
                  _UpperCAmelCase    :			Any              =					self._remove_meta_keys(A		)
                  if configa == configa:
                       print(f'Warning !: Mismatch in keys {meta_keysa} and {meta_keysa}.'		)
                       return True
             return False
  
  
  
        def 		snake_case_      (  self  :			Tuple  ,			A  :			Dict		):
             _UpperCAmelCase    :			Any              =					[]
             _UpperCAmelCase    :			str              =					config_dict.copy()
             for key in config_dict.keys():
                  if key.startswith("_"		):
                       temp_dict.pop(A		)
                       meta_keys.append(A		)
             return (temp_dict, meta_keys)
  
  
  
        @torch.no_grad()
        def 		snake_case_      (  self  :			Tuple  ,			A  :			List[Union[str, os.PathLike]]  ,			**A  :			Optional[Any]		):
             _UpperCAmelCase    :			Dict              =					kwargs.pop("cache_dir"  ,			A		)
             _UpperCAmelCase    :			List[Any]              =					kwargs.pop("resume_download"  ,			A		)
             _UpperCAmelCase    :			Any              =					kwargs.pop("force_download"  ,			A		)
             _UpperCAmelCase    :			Optional[int]              =					kwargs.pop("proxies"  ,			A		)
             _UpperCAmelCase    :			Tuple              =					kwargs.pop("local_files_only"  ,			A		)
             _UpperCAmelCase    :			List[str]              =					kwargs.pop("use_auth_token"  ,			A		)
             _UpperCAmelCase    :			int              =					kwargs.pop("revision"  ,			A		)
             _UpperCAmelCase    :			List[Any]              =					kwargs.pop("torch_dtype"  ,			A		)
             _UpperCAmelCase    :			Union[str, Any]              =					kwargs.pop("device_map"  ,			A		)
  
             _UpperCAmelCase    :			Dict              =					kwargs.pop("alpha"  ,			0.5		)
             _UpperCAmelCase    :			Tuple              =					kwargs.pop("interp"  ,			A		)
  
             print("Received list"  ,			A		)
             print(f'Combining with alpha={alpha}, interpolation mode={interp}'		)
  
             _UpperCAmelCase    :			List[Any]              =					len(A		)
             # Ignore result from model_index_json comparision of the two checkpoints
             _UpperCAmelCase    :			Union[str, Any]              =					kwargs.pop("force"  ,			A		)
  
             # If less than 2 checkpoints, nothing to merge. If more than 3, not supported for now.
             if checkpoint_count > 3 or checkpoint_count < 2:
                  raise ValueError(
                      "Received incorrect number of checkpoints to merge. Ensure that either 2 or 3 checkpoints are being"
                      " passed."		)
  
             print("Received the right number of checkpoints"		)
             # chkpt0, chkpt1 = pretrained_model_name_or_path_list[0:2]
             # chkpt2 = pretrained_model_name_or_path_list[2] if checkpoint_count == 3 else None
  
             # Validate that the checkpoints can be merged
             # Step 1: Load the model config and compare the checkpoints. We'll compare the model_index.json first while ignoring the keys starting with '_'
             _UpperCAmelCase    :			Optional[Any]              =					[]
             for pretrained_model_name_or_path in pretrained_model_name_or_path_list:
                  _UpperCAmelCase    :			Union[str, Any]              =					DiffusionPipeline.load_config(
                      A  ,			cache_dir=A  ,			resume_download=A  ,			force_download=A  ,			proxies=A  ,			local_files_only=A  ,			use_auth_token=A  ,			revision=A  ,			)
                  config_dicts.append(A		)
  
             _UpperCAmelCase    :			Optional[int]              =					True
             for idx in range(1  ,			len(A		)		):
                  comparison_result &= self._compare_model_configs(config_dicts[idx - 1]  ,			config_dicts[idx]		)
                  if not force and comparison_result is False:
                       raise ValueError("Incompatible checkpoints. Please check model_index.json for the models."		)
                       print(config_dicts[0]  ,			config_dicts[1]		)
             print("Compatible model_index.json files found"		)
             # Step 2: Basic Validation has succeeded. Let's download the models and save them into our local files.
             _UpperCAmelCase    :			List[str]              =					[]
             for pretrained_model_name_or_path, config_dict in zip(A  ,			A		):
                  _UpperCAmelCase    :			Optional[int]              =					[k for k in config_dict.keys() if not k.startswith("_"		)]
                  _UpperCAmelCase    :			Union[str, Any]              =					[os.path.join(A  ,			"*"		) for k in folder_names]
                  allow_patterns += [
                      WEIGHTS_NAME,
                      SCHEDULER_CONFIG_NAME,
                      CONFIG_NAME,
                      ONNX_WEIGHTS_NAME,
                      DiffusionPipeline.config_name,
                  ]
                  _UpperCAmelCase    :			Any              =					config_dict.get("_class_name"		)
                  _UpperCAmelCase    :			Union[str, Any]              =					{"diffusers": __version__, "pipeline_class": requested_pipeline_class}
  
                  _UpperCAmelCase    :			Any              =					(
                      pretrained_model_name_or_path
                      if os.path.isdir(A		)
                      else snapshot_download(
                          A  ,			cache_dir=A  ,			resume_download=A  ,			proxies=A  ,			local_files_only=A  ,			use_auth_token=A  ,			revision=A  ,			allow_patterns=A  ,			user_agent=A  ,			)
                  )
                  print("Cached Folder"  ,			A		)
                  cached_folders.append(A		)
  
             # Step 3:-
             # Load the first checkpoint as a diffusion pipeline and modify its module state_dict in place
             _UpperCAmelCase    :			List[str]              =					DiffusionPipeline.from_pretrained(
                 cached_folders[0]  ,			torch_dtype=A  ,			device_map=A		)
             final_pipe.to(self.device		)
  
             _UpperCAmelCase    :			Tuple              =					None
             if len(A		) > 2:
                  _UpperCAmelCase    :			Dict              =					os.path.join(cached_folders[2]		)
  
             if interp == "sigmoid":
                  _UpperCAmelCase    :			Union[str, Any]              =					CheckpointMergerPipeline.sigmoid
             elif interp == "inv_sigmoid":
                  _UpperCAmelCase    :			Tuple              =					CheckpointMergerPipeline.inv_sigmoid
             elif interp == "add_diff":
                  _UpperCAmelCase    :			Union[str, Any]              =					CheckpointMergerPipeline.add_difference
             else:
                  _UpperCAmelCase    :			Optional[int]              =					CheckpointMergerPipeline.weighted_sum
  
             # Find each module's state dict.
             for attr in final_pipe.config.keys():
                  if not attr.startswith("_"		):
                       _UpperCAmelCase    :			str              =					os.path.join(cached_folders[1]  ,			A		)
                       if os.path.exists(A		):
                            _UpperCAmelCase    :			Tuple              =					[
                                *glob.glob(os.path.join(A  ,			"*.safetensors"		)		),
                                *glob.glob(os.path.join(A  ,			"*.bin"		)		),
                            ]
                            _UpperCAmelCase    :			Optional[Any]              =					files[0] if len(A		) > 0 else None
                       if len(A		) < 3:
                            _UpperCAmelCase    :			Dict              =					None
                       else:
                            _UpperCAmelCase    :			Union[str, Any]              =					os.path.join(cached_folders[2]  ,			A		)
                            if os.path.exists(A		):
                                 _UpperCAmelCase    :			Dict              =					[
                                     *glob.glob(os.path.join(A  ,			"*.safetensors"		)		),
                                     *glob.glob(os.path.join(A  ,			"*.bin"		)		),
                                 ]
                                 _UpperCAmelCase    :			Tuple              =					files[0] if len(A		) > 0 else None
                  # For an attr if both checkpoint_path_1 and 2 are None, ignore.
                  # If atleast one is present, deal with it according to interp method, of course only if the state_dict keys match.
                       if checkpoint_path_a is None and checkpoint_path_a is None:
                            print(f'Skipping {attr}: not present in 2nd or 3d model'		)
                            continue
                       try:
                            _UpperCAmelCase    :			List[str]              =					getattr(A  ,			A		)
                            if isinstance(A  ,			A		):  # ignore requires_safety_checker boolean
                                 continue
                            _UpperCAmelCase    :			Optional[int]              =					getattr(A  ,			"state_dict"		)
                            _UpperCAmelCase    :			Tuple              =					theta_a()
  
                            _UpperCAmelCase    :			Any              =					getattr(A  ,			"load_state_dict"		)
                            _UpperCAmelCase    :			Optional[Any]              =					(
                                safetensors.torch.load_file(A		)
                                if (is_safetensors_available() and checkpoint_path_a.endswith(".safetensors"		))
                                else torch.load(A  ,			map_location="cpu"		)
                            )
                            _UpperCAmelCase    :			int              =					None
                            if checkpoint_path_a:
                                 _UpperCAmelCase    :			str              =					(
                                     safetensors.torch.load_file(A		)
                                     if (is_safetensors_available() and checkpoint_path_a.endswith(".safetensors"		))
                                     else torch.load(A  ,			map_location="cpu"		)
                                 )
  
                            if not theta_a.keys() == theta_a.keys():
                                 print(f'Skipping {attr}: key mismatch'		)
                                 continue
                            if theta_a and not theta_a.keys() == theta_a.keys():
                                 print(f'Skipping {attr}:y mismatch'		)
                       except Exception as e:
                            print(f'Skipping {attr} do to an unexpected error: {str(A		)}'		)
                            continue
                       print(f'MERGING {attr}'		)
  
                       for key in theta_a.keys():
                            if theta_a:
                                 _UpperCAmelCase    :			Optional[int]              =					theta_func(theta_a[key]  ,			theta_a[key]  ,			theta_a[key]  ,			A		)
                            else:
                                 _UpperCAmelCase    :			Dict              =					theta_func(theta_a[key]  ,			theta_a[key]  ,			A  ,			A		)
  
                       del theta_a
                       del theta_a
                       update_theta_a(A		)
  
                       del theta_a
             return final_pipe
  
  
  
        @staticmethod
        def 		snake_case_      (  A  :			Tuple  ,			A  :			Dict  ,			A  :			Dict  ,			A  :			int		):
             return ((1 - alpha) * thetaa) + (alpha * thetaa)
  
  
  
        @staticmethod
        def 		snake_case_      (  A  :			Tuple  ,			A  :			int  ,			A  :			Optional[Any]  ,			A  :			int		):
             _UpperCAmelCase    :			str              =					alpha * alpha * (3 - (2 * alpha))
             return thetaa + ((thetaa - thetaa) * alpha)
  
  
  
        @staticmethod
        def 		snake_case_      (  A  :			Any  ,			A  :			int  ,			A  :			Optional[int]  ,			A  :			Union[str, Any]		):
             import math
  
             _UpperCAmelCase    :			Optional[Any]              =					0.5 - math.sin(math.asin(1.0 - 2.0 * alpha		) / 3.0		)
             return thetaa + ((thetaa - thetaa) * alpha)
  
  
  
        @staticmethod
        def 		snake_case_      (  A  :			Union[str, Any]  ,			A  :			Any  ,			A  :			Optional[int]  ,			A  :			str		):
             return thetaa + (thetaa - thetaa) * (1.0 - alpha)
  
style_context: 
  
  
  
  """simple docstring"""
  
  
  
  
  import argparse
  import json
  import re
  import string
  import sys
  from collections import Counter
  
  def 		__snake_case		(   SCREAMING_SNAKE_CASE__			:		Optional[int]       )						->     Union[str, Any]:
  
  
  
  
  
       '''simple docstring'''
  
       def remove_articles(SCREAMING_SNAKE_CASE__			:		Tuple       ):
            return re.sub(R"\b(a|an|the)\b"		,						" "		,						SCREAMING_SNAKE_CASE__       )
  
       def white_space_fix(SCREAMING_SNAKE_CASE__			:		Any       ):
            return " ".join(text.split()       )
  
       def remove_punc(SCREAMING_SNAKE_CASE__			:		Optional[int]       ):
            _UpperCAmelCase    :			List[str]              =					set(string.punctuation       )
            return "".join(ch for ch in text if ch not in exclude       )
  
       def lower(SCREAMING_SNAKE_CASE__			:		List[str]       ):
            return text.lower()
  
       return white_space_fix(remove_articles(remove_punc(lower(SCREAMING_SNAKE_CASE__       )       )       )       )
  
  def 		__snake_case		(   SCREAMING_SNAKE_CASE__			:		Union[str, Any]		,						SCREAMING_SNAKE_CASE__			:		str       )						->     Dict:
  
  
  
  
  
       '''simple docstring'''
  
       _UpperCAmelCase    :			List[Any]              =					normalize_answer(SCREAMING_SNAKE_CASE__       ).split()
       _UpperCAmelCase    :			Tuple              =					normalize_answer(SCREAMING_SNAKE_CASE__       ).split()
       _UpperCAmelCase    :			List[Any]              =					Counter(SCREAMING_SNAKE_CASE__       ) & Counter(SCREAMING_SNAKE_CASE__       )
       _UpperCAmelCase    :			List[str]              =					sum(common.values()       )
       if num_same == 0:
            return 0
       _UpperCAmelCase    :			Union[str, Any]              =					1.0 * num_same / len(SCREAMING_SNAKE_CASE__       )
       _UpperCAmelCase    :			Union[str, Any]              =					1.0 * num_same / len(SCREAMING_SNAKE_CASE__       )
       _UpperCAmelCase    :			Union[str, Any]              =					(2 * precision * recall) / (precision + recall)
       return fa
  
  def 		__snake_case		(   SCREAMING_SNAKE_CASE__			:		Union[str, Any]		,						SCREAMING_SNAKE_CASE__			:		Dict       )						->     str:
  
  
  
  
  
       '''simple docstring'''
  
       return normalize_answer(SCREAMING_SNAKE_CASE__       ) == normalize_answer(SCREAMING_SNAKE_CASE__       )
  
  def 		__snake_case		(   SCREAMING_SNAKE_CASE__			:		List[Any]		,						SCREAMING_SNAKE_CASE__			:		Dict		,						SCREAMING_SNAKE_CASE__			:		Optional[Any]       )						->     str:
  
  
  
  
  
       '''simple docstring'''
  
       _UpperCAmelCase    :			int              =					[]
       for ground_truth in ground_truths:
            _UpperCAmelCase    :			Dict              =					metric_fn(SCREAMING_SNAKE_CASE__		,						SCREAMING_SNAKE_CASE__       )
            scores_for_ground_truths.append(SCREAMING_SNAKE_CASE__       )
       return max(SCREAMING_SNAKE_CASE__       )
  
  def 		__snake_case		(   SCREAMING_SNAKE_CASE__			:		Optional[int]		,						SCREAMING_SNAKE_CASE__			:		Any       )						->     Tuple:
  
  
  
  
  
       '''simple docstring'''
  
       _UpperCAmelCase    :			str              =					0
       _UpperCAmelCase    :			int              =					[]
       for passage in dataset:
            for qa in passage["qas"]:
                 total += 1
                 if qa["id"] not in predictions:
                      _UpperCAmelCase    :			List[Any]              =					f'Unanswered question {qa["id"]} will receive score 0.'
                      print(SCREAMING_SNAKE_CASE__		,						file=sys.stderr       )
                      continue
  
                 _UpperCAmelCase    :			Union[str, Any]              =					[x["text"] for x in qa["answers"]]
                 _UpperCAmelCase    :			Optional[int]              =					predictions[qa["id"]]
  
                 _UpperCAmelCase    :			int              =					metric_max_over_ground_truths(SCREAMING_SNAKE_CASE__		,						SCREAMING_SNAKE_CASE__		,						SCREAMING_SNAKE_CASE__       )
                 if int(_exact_match       ) == 1:
                      correct_ids.append(qa["id"]       )
                 exact_match += _exact_match
  
                 fa += metric_max_over_ground_truths(SCREAMING_SNAKE_CASE__		,						SCREAMING_SNAKE_CASE__		,						SCREAMING_SNAKE_CASE__       )
  
       _UpperCAmelCase    :			List[str]              =					exact_match / total
       _UpperCAmelCase    :			str              =					fa / total
  
       return {"exact_match": exact_match, "f1": fa}, correct_ids
  
  
  if __name__ == "__main__":
   _lowerCAmelCase       :      Any							=							"1.0"
   _lowerCAmelCase       :      Any							=							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.")
   _lowerCAmelCase       :      Tuple							=							parser.parse_args()
  
   with open(args.data_file) as data_file:
    _lowerCAmelCase       :      int							=							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,
     )
    _lowerCAmelCase       :      List[str]							=							dataset_json["data"]
  
   with open(args.pred_file) as pred_file:
    _lowerCAmelCase       :      str							=							json.load(pred_file)
  
   _lowerCAmelCase,		_lowerCAmelCase       :      List[Any]							=							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)
  