code: 
  
  
  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 						A__      (					snake_case__			):
  
  
  
  
  
  
  
      """simple docstring"""
  
      def __init__( self					):
           self.register_to_config()
           super().__init__()
      def 	a_    ( self    ,      __snake_case    ,      __snake_case					):
           if dicta == dicta:
                return True
           else:
                snake_case				,						snake_case					=       self._remove_meta_keys(__snake_case					)
                snake_case				,						snake_case					=       self._remove_meta_keys(__snake_case					)
                if configa == configa:
                     print(F'''Warning !: Mismatch in keys {meta_keysa} and {meta_keysa}.'''					)
                     return True
           return False
      def 	a_    ( self    ,      __snake_case					):
           snake_case					=       []
           snake_case					=       config_dict.copy()
           for key in config_dict.keys():
                if key.startswith('''_'''					):
                     temp_dict.pop(__snake_case					)
                     meta_keys.append(__snake_case					)
           return (temp_dict, meta_keys)
      @torch.no_grad()
      def 	a_    ( self    ,      __snake_case    ,      **__snake_case					):
           snake_case					=       kwargs.pop('''cache_dir'''    ,      __snake_case					)
           snake_case					=       kwargs.pop('''resume_download'''    ,      __snake_case					)
           snake_case					=       kwargs.pop('''force_download'''    ,      __snake_case					)
           snake_case					=       kwargs.pop('''proxies'''    ,      __snake_case					)
           snake_case					=       kwargs.pop('''local_files_only'''    ,      __snake_case					)
           snake_case					=       kwargs.pop('''use_auth_token'''    ,      __snake_case					)
           snake_case					=       kwargs.pop('''revision'''    ,      __snake_case					)
           snake_case					=       kwargs.pop('''torch_dtype'''    ,      __snake_case					)
           snake_case					=       kwargs.pop('''device_map'''    ,      __snake_case					)
  
           snake_case					=       kwargs.pop('''alpha'''    ,      0.5					)
           snake_case					=       kwargs.pop('''interp'''    ,      __snake_case					)
  
           print('''Received list'''    ,      __snake_case					)
           print(F'''Combining with alpha={alpha}, interpolation mode={interp}'''					)
  
           snake_case					=       len(__snake_case					)
           # Ignore result from model_index_json comparision of the two checkpoints
           snake_case					=       kwargs.pop('''force'''    ,      __snake_case					)
  
           # 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 '_'
           snake_case					=       []
           for pretrained_model_name_or_path in pretrained_model_name_or_path_list:
                snake_case					=       DiffusionPipeline.load_config(
                    __snake_case    ,      cache_dir=__snake_case    ,      resume_download=__snake_case    ,      force_download=__snake_case    ,      proxies=__snake_case    ,      local_files_only=__snake_case    ,      use_auth_token=__snake_case    ,      revision=__snake_case    ,      )
                config_dicts.append(__snake_case					)
  
           snake_case					=       True
           for idx in range(1    ,      len(__snake_case					)					):
                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.
           snake_case					=       []
           for pretrained_model_name_or_path, config_dict in zip(__snake_case    ,      __snake_case					):
                snake_case					=       [k for k in config_dict.keys() if not k.startswith('''_'''					)]
                snake_case					=       [os.path.join(__snake_case    ,      '''*'''					) for k in folder_names]
                allow_patterns += [
                    WEIGHTS_NAME,
                    SCHEDULER_CONFIG_NAME,
                    CONFIG_NAME,
                    ONNX_WEIGHTS_NAME,
                    DiffusionPipeline.config_name,
                ]
                snake_case					=       config_dict.get('''_class_name'''					)
                snake_case					=       {'''diffusers''': __version__, '''pipeline_class''': requested_pipeline_class}
  
                snake_case					=       (
                    pretrained_model_name_or_path
                    if os.path.isdir(__snake_case					)
                    else snapshot_download(
                        __snake_case    ,      cache_dir=__snake_case    ,      resume_download=__snake_case    ,      proxies=__snake_case    ,      local_files_only=__snake_case    ,      use_auth_token=__snake_case    ,      revision=__snake_case    ,      allow_patterns=__snake_case    ,      user_agent=__snake_case    ,      )
                )
                print('''Cached Folder'''    ,      __snake_case					)
                cached_folders.append(__snake_case					)
  
           # Step 3:-
           # Load the first checkpoint as a diffusion pipeline and modify its module state_dict in place
           snake_case					=       DiffusionPipeline.from_pretrained(
               cached_folders[0]    ,      torch_dtype=__snake_case    ,      device_map=__snake_case					)
           final_pipe.to(self.device					)
  
           snake_case					=       None
           if len(__snake_case					) > 2:
                snake_case					=       os.path.join(cached_folders[2]					)
  
           if interp == "sigmoid":
                snake_case					=       CheckpointMergerPipeline.sigmoid
           elif interp == "inv_sigmoid":
                snake_case					=       CheckpointMergerPipeline.inv_sigmoid
           elif interp == "add_diff":
                snake_case					=       CheckpointMergerPipeline.add_difference
           else:
                snake_case					=       CheckpointMergerPipeline.weighted_sum
  
           # Find each module's state dict.
           for attr in final_pipe.config.keys():
                if not attr.startswith('''_'''					):
                     snake_case					=       os.path.join(cached_folders[1]    ,      __snake_case					)
                     if os.path.exists(__snake_case					):
                          snake_case					=       [
                              *glob.glob(os.path.join(__snake_case    ,      '''*.safetensors'''					)					),
                              *glob.glob(os.path.join(__snake_case    ,      '''*.bin'''					)					),
                          ]
                          snake_case					=       files[0] if len(__snake_case					) > 0 else None
                     if len(__snake_case					) < 3:
                          snake_case					=       None
                     else:
                          snake_case					=       os.path.join(cached_folders[2]    ,      __snake_case					)
                          if os.path.exists(__snake_case					):
                               snake_case					=       [
                                   *glob.glob(os.path.join(__snake_case    ,      '''*.safetensors'''					)					),
                                   *glob.glob(os.path.join(__snake_case    ,      '''*.bin'''					)					),
                               ]
                               snake_case					=       files[0] if len(__snake_case					) > 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:
                          snake_case					=       getattr(__snake_case    ,      __snake_case					)
                          if isinstance(__snake_case    ,      __snake_case					):  # ignore requires_safety_checker boolean
                               continue
                          snake_case					=       getattr(__snake_case    ,      '''state_dict'''					)
                          snake_case					=       theta_a()
  
                          snake_case					=       getattr(__snake_case    ,      '''load_state_dict'''					)
                          snake_case					=       (
                              safetensors.torch.load_file(__snake_case					)
                              if (is_safetensors_available() and checkpoint_path_a.endswith('''.safetensors'''					))
                              else torch.load(__snake_case    ,      map_location='''cpu'''					)
                          )
                          snake_case					=       None
                          if checkpoint_path_a:
                               snake_case					=       (
                                   safetensors.torch.load_file(__snake_case					)
                                   if (is_safetensors_available() and checkpoint_path_a.endswith('''.safetensors'''					))
                                   else torch.load(__snake_case    ,      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(__snake_case					)}'''					)
                          continue
                     print(F'''MERGING {attr}'''					)
  
                     for key in theta_a.keys():
                          if theta_a:
                               snake_case					=       theta_func(theta_a[key]    ,      theta_a[key]    ,      theta_a[key]    ,      __snake_case					)
                          else:
                               snake_case					=       theta_func(theta_a[key]    ,      theta_a[key]    ,      __snake_case    ,      __snake_case					)
  
                     del theta_a
                     del theta_a
                     update_theta_a(__snake_case					)
  
                     del theta_a
           return final_pipe
      @staticmethod
      def 	a_    ( __snake_case    ,      __snake_case    ,      __snake_case    ,      __snake_case					):
           return ((1 - alpha) * thetaa) + (alpha * thetaa)
      @staticmethod
      def 	a_    ( __snake_case    ,      __snake_case    ,      __snake_case    ,      __snake_case					):
           snake_case					=       alpha * alpha * (3 - (2 * alpha))
           return thetaa + ((thetaa - thetaa) * alpha)
      @staticmethod
      def 	a_    ( __snake_case    ,      __snake_case    ,      __snake_case    ,      __snake_case					):
           import math
  
           snake_case					=       0.5 - math.sin(math.asin(1.0 - 2.0 * alpha					) / 3.0					)
           return thetaa + ((thetaa - thetaa) * alpha)
  
  
  
  
      @staticmethod
      def 	a_    ( __snake_case    ,      __snake_case    ,      __snake_case    ,      __snake_case					):
           return thetaa + (thetaa - thetaa) * (1.0 - alpha)
  
  
  
  
style_context: 
  
  
  import torch
  
  from accelerate import Accelerator, DistributedType
  
  class 						A__      :
  
  
  
  
  
  
  
      """simple docstring"""
  
      def __enter__( self					):
           if self.enabled:
                snake_case					=       self.model.no_sync()
                self.model_sync_obj.__enter__()
  
           return self
      def __exit__( self    ,      __snake_case    ,      __snake_case    ,      __snake_case					):
           if self.enabled:
                # Average all models on exit
                self._sync_and_avg_model_params()
                self.model_sync_obj.__exit__(__snake_case    ,      __snake_case    ,      __snake_case					)
      def __init__( self    ,      __snake_case    ,      __snake_case    ,      __snake_case    ,      __snake_case = True					):
           if accelerator.distributed_type not in [
               DistributedType.NO,
               DistributedType.MULTI_CPU,
               DistributedType.MULTI_GPU,
           ]:
                raise NotImplementedError('''LocalSGD is supported only for CPUs and GPUs (no DeepSpeed or MegatronLM)'''					)
           snake_case					=       enabled and accelerator.distributed_type != DistributedType.NO
           snake_case					=       0
           if self.enabled:
                snake_case					=       accelerator
                snake_case					=       model
                snake_case					=       local_sgd_steps
      def 	a_    ( self					):
           self.num_steps += 1
           if not self.enabled:
                return
  
           if self.num_steps % self.local_sgd_steps == 0:
                self._sync_and_avg_model_params()
  
  
  
  
      def 	a_    ( self					):
           self.accelerator.wait_for_everyone()
           with self.accelerator.autocast():
                for param in self.model.parameters():
                     snake_case					=       self.accelerator.reduce(param.data    ,      reduction='''mean'''					)
  
  
  
  
  