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 						lowerCamelCase			(					__lowerCamelCase				):
  
  
  
  
  
  
  
  	def __init__(    self			:List[Any] )		->			List[str]:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				self.register_to_config()
  				super().__init__()
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:str      ,    lowercase			:str      ,    lowercase			:str )		->			str:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				if dicta == dicta:
  							return True
  				else:
  							SCREAMING_SNAKE_CASE	,       SCREAMING_SNAKE_CASE    	=   self._remove_meta_keys(lowercase )
  							SCREAMING_SNAKE_CASE	,       SCREAMING_SNAKE_CASE    	=   self._remove_meta_keys(lowercase )
  							if configa == configa:
  										print(f"""Warning !: Mismatch in keys {meta_keysa} and {meta_keysa}.""" )
  										return True
  				return False
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:int      ,    lowercase			:Dict )		->			Optional[Any]:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				SCREAMING_SNAKE_CASE    	=   []
  				SCREAMING_SNAKE_CASE    	=   config_dict.copy()
  				for key in config_dict.keys():
  							if key.startswith('''_''' ):
  										temp_dict.pop(lowercase )
  										meta_keys.append(lowercase )
  				return (temp_dict, meta_keys)
  
  
  
  
  
  
  
  	@torch.no_grad()
  	def    snake_case__    (    self			:Tuple      ,    lowercase			:List[Union[str, os.PathLike]]      ,    **lowercase			:List[str] )		->			List[Any]:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				SCREAMING_SNAKE_CASE    	=   kwargs.pop('''cache_dir'''      ,    lowercase )
  				SCREAMING_SNAKE_CASE    	=   kwargs.pop('''resume_download'''      ,    lowercase )
  				SCREAMING_SNAKE_CASE    	=   kwargs.pop('''force_download'''      ,    lowercase )
  				SCREAMING_SNAKE_CASE    	=   kwargs.pop('''proxies'''      ,    lowercase )
  				SCREAMING_SNAKE_CASE    	=   kwargs.pop('''local_files_only'''      ,    lowercase )
  				SCREAMING_SNAKE_CASE    	=   kwargs.pop('''use_auth_token'''      ,    lowercase )
  				SCREAMING_SNAKE_CASE    	=   kwargs.pop('''revision'''      ,    lowercase )
  				SCREAMING_SNAKE_CASE    	=   kwargs.pop('''torch_dtype'''      ,    lowercase )
  				SCREAMING_SNAKE_CASE    	=   kwargs.pop('''device_map'''      ,    lowercase )
  
  				SCREAMING_SNAKE_CASE    	=   kwargs.pop('''alpha'''      ,    0.5 )
  				SCREAMING_SNAKE_CASE    	=   kwargs.pop('''interp'''      ,    lowercase )
  
  				print('''Received list'''      ,    lowercase )
  				print(f"""Combining with alpha={alpha}, interpolation mode={interp}""" )
  
  				SCREAMING_SNAKE_CASE    	=   len(lowercase )
  				# Ignore result from model_index_json comparision of the two checkpoints
  				SCREAMING_SNAKE_CASE    	=   kwargs.pop('''force'''      ,    lowercase )
  
  				# 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 '_'
  				SCREAMING_SNAKE_CASE    	=   []
  				for pretrained_model_name_or_path in pretrained_model_name_or_path_list:
  							SCREAMING_SNAKE_CASE    	=   DiffusionPipeline.load_config(
  							    lowercase      ,    cache_dir=lowercase      ,    resume_download=lowercase      ,    force_download=lowercase      ,    proxies=lowercase      ,    local_files_only=lowercase      ,    use_auth_token=lowercase      ,    revision=lowercase      ,    )
  							config_dicts.append(lowercase )
  
  				SCREAMING_SNAKE_CASE    	=   True
  				for idx in range(1      ,    len(lowercase ) ):
  							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.
  				SCREAMING_SNAKE_CASE    	=   []
  				for pretrained_model_name_or_path, config_dict in zip(lowercase      ,    lowercase ):
  							SCREAMING_SNAKE_CASE    	=   [k for k in config_dict.keys() if not k.startswith('''_''' )]
  							SCREAMING_SNAKE_CASE    	=   [os.path.join(lowercase      ,    '''*''' ) for k in folder_names]
  							allow_patterns += [
  							    WEIGHTS_NAME,
  							    SCHEDULER_CONFIG_NAME,
  							    CONFIG_NAME,
  							    ONNX_WEIGHTS_NAME,
  							    DiffusionPipeline.config_name,
  							]
  							SCREAMING_SNAKE_CASE    	=   config_dict.get('''_class_name''' )
  							SCREAMING_SNAKE_CASE    	=   {'''diffusers''': __version__, '''pipeline_class''': requested_pipeline_class}
  
  							SCREAMING_SNAKE_CASE    	=   (
  							    pretrained_model_name_or_path
  							    if os.path.isdir(lowercase )
  							    else snapshot_download(
  							        lowercase      ,    cache_dir=lowercase      ,    resume_download=lowercase      ,    proxies=lowercase      ,    local_files_only=lowercase      ,    use_auth_token=lowercase      ,    revision=lowercase      ,    allow_patterns=lowercase      ,    user_agent=lowercase      ,    )
  							)
  							print('''Cached Folder'''      ,    lowercase )
  							cached_folders.append(lowercase )
  
  				# Step 3:-
  				# Load the first checkpoint as a diffusion pipeline and modify its module state_dict in place
  				SCREAMING_SNAKE_CASE    	=   DiffusionPipeline.from_pretrained(
  				    cached_folders[0]      ,    torch_dtype=lowercase      ,    device_map=lowercase )
  				final_pipe.to(self.device )
  
  				SCREAMING_SNAKE_CASE    	=   None
  				if len(lowercase ) > 2:
  							SCREAMING_SNAKE_CASE    	=   os.path.join(cached_folders[2] )
  
  				if interp == "sigmoid":
  							SCREAMING_SNAKE_CASE    	=   CheckpointMergerPipeline.sigmoid
  				elif interp == "inv_sigmoid":
  							SCREAMING_SNAKE_CASE    	=   CheckpointMergerPipeline.inv_sigmoid
  				elif interp == "add_diff":
  							SCREAMING_SNAKE_CASE    	=   CheckpointMergerPipeline.add_difference
  				else:
  							SCREAMING_SNAKE_CASE    	=   CheckpointMergerPipeline.weighted_sum
  
  				# Find each module's state dict.
  				for attr in final_pipe.config.keys():
  							if not attr.startswith('''_''' ):
  										SCREAMING_SNAKE_CASE    	=   os.path.join(cached_folders[1]      ,    lowercase )
  										if os.path.exists(lowercase ):
  													SCREAMING_SNAKE_CASE    	=   [
  													    *glob.glob(os.path.join(lowercase      ,    '''*.safetensors''' ) ),
  													    *glob.glob(os.path.join(lowercase      ,    '''*.bin''' ) ),
  													]
  													SCREAMING_SNAKE_CASE    	=   files[0] if len(lowercase ) > 0 else None
  										if len(lowercase ) < 3:
  													SCREAMING_SNAKE_CASE    	=   None
  										else:
  													SCREAMING_SNAKE_CASE    	=   os.path.join(cached_folders[2]      ,    lowercase )
  													if os.path.exists(lowercase ):
  																SCREAMING_SNAKE_CASE    	=   [
  																    *glob.glob(os.path.join(lowercase      ,    '''*.safetensors''' ) ),
  																    *glob.glob(os.path.join(lowercase      ,    '''*.bin''' ) ),
  																]
  																SCREAMING_SNAKE_CASE    	=   files[0] if len(lowercase ) > 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:
  													SCREAMING_SNAKE_CASE    	=   getattr(lowercase      ,    lowercase )
  													if isinstance(lowercase      ,    lowercase ):  # ignore requires_safety_checker boolean
  																continue
  													SCREAMING_SNAKE_CASE    	=   getattr(lowercase      ,    '''state_dict''' )
  													SCREAMING_SNAKE_CASE    	=   theta_a()
  
  													SCREAMING_SNAKE_CASE    	=   getattr(lowercase      ,    '''load_state_dict''' )
  													SCREAMING_SNAKE_CASE    	=   (
  													    safetensors.torch.load_file(lowercase )
  													    if (is_safetensors_available() and checkpoint_path_a.endswith('''.safetensors''' ))
  													    else torch.load(lowercase      ,    map_location='''cpu''' )
  													)
  													SCREAMING_SNAKE_CASE    	=   None
  													if checkpoint_path_a:
  																SCREAMING_SNAKE_CASE    	=   (
  																    safetensors.torch.load_file(lowercase )
  																    if (is_safetensors_available() and checkpoint_path_a.endswith('''.safetensors''' ))
  																    else torch.load(lowercase      ,    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(lowercase )}""" )
  													continue
  										print(f"""MERGING {attr}""" )
  
  										for key in theta_a.keys():
  													if theta_a:
  																SCREAMING_SNAKE_CASE    	=   theta_func(theta_a[key]      ,    theta_a[key]      ,    theta_a[key]      ,    lowercase )
  													else:
  																SCREAMING_SNAKE_CASE    	=   theta_func(theta_a[key]      ,    theta_a[key]      ,    lowercase      ,    lowercase )
  
  										del theta_a
  										del theta_a
  										update_theta_a(lowercase )
  
  										del theta_a
  				return final_pipe
  
  
  
  
  
  
  
  	@staticmethod
  	def    snake_case__    (    lowercase			:int      ,    lowercase			:str      ,    lowercase			:List[Any]      ,    lowercase			:str )		->			Tuple:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				return ((1 - alpha) * thetaa) + (alpha * thetaa)
  
  
  
  
  
  
  
  	@staticmethod
  	def    snake_case__    (    lowercase			:Optional[Any]      ,    lowercase			:List[Any]      ,    lowercase			:int      ,    lowercase			:Optional[Any] )		->			Optional[Any]:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				SCREAMING_SNAKE_CASE    	=   alpha * alpha * (3 - (2 * alpha))
  				return thetaa + ((thetaa - thetaa) * alpha)
  
  
  
  
  
  
  
  	@staticmethod
  	def    snake_case__    (    lowercase			:Dict      ,    lowercase			:List[Any]      ,    lowercase			:Optional[int]      ,    lowercase			:int )		->			Union[str, Any]:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				import math
  
  				SCREAMING_SNAKE_CASE    	=   0.5 - math.sin(math.asin(1.0 - 2.0 * alpha ) / 3.0 )
  				return thetaa + ((thetaa - thetaa) * alpha)
  
  
  
  
  
  
  
  	@staticmethod
  	def    snake_case__    (    lowercase			:Union[str, Any]      ,    lowercase			:Tuple      ,    lowercase			:Optional[int]      ,    lowercase			:Optional[int] )		->			Any:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				return thetaa + (thetaa - thetaa) * (1.0 - alpha)
style_context: 
  import json
  import os
  import unittest
  
  from transformers.models.gpt_neox_japanese.tokenization_gpt_neox_japanese import (
      VOCAB_FILES_NAMES,
      GPTNeoXJapaneseTokenizer,
  )
  from transformers.testing_utils import require_tokenizers, slow
  
  from ...test_tokenization_common import TokenizerTesterMixin
  
  
  
  
  
  @require_tokenizers
  class 						lowerCamelCase			(					__lowerCamelCase   ,		unittest.TestCase				):
  	UpperCamelCase_     :				List[str]								=  GPTNeoXJapaneseTokenizer
  	UpperCamelCase_     :				List[Any]								=  False
  	UpperCamelCase_     :				int								=  {'do_clean_text': False, 'add_prefix_space': False}
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:Optional[int] )		->			Union[str, Any]:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				super().setUp()
  
  				SCREAMING_SNAKE_CASE    	=   [
  				    '''こん''',
  				    '''こんに''',
  				    '''にちは''',
  				    '''ばんは''',
  				    '''世界,㔺界''',
  				    '''、''',
  				    '''。''',
  				    '''<BR>''',
  				    '''<SP>''',
  				    '''<TAB>''',
  				    '''<URL>''',
  				    '''<EMAIL>''',
  				    '''<TEL>''',
  				    '''<DATE>''',
  				    '''<PRICE>''',
  				    '''<BLOCK>''',
  				    '''<KIGOU>''',
  				    '''<U2000U2BFF>''',
  				    '''<|emoji1|>''',
  				    '''<unk>''',
  				    '''<|startoftext|>''',
  				    '''<|endoftext|>''',
  				]
  				SCREAMING_SNAKE_CASE    	=   {'''emoji''': {'''\ud83d\ude00''': '''<|emoji1|>'''}, '''emoji_inv''': {'''<|emoji1|>''': '''\ud83d\ude00'''}}  # 😀
  				SCREAMING_SNAKE_CASE    	=   {'''unk_token''': '''<unk>'''}
  
  				SCREAMING_SNAKE_CASE    	=   os.path.join(self.tmpdirname      ,    VOCAB_FILES_NAMES['''vocab_file'''] )
  				SCREAMING_SNAKE_CASE    	=   os.path.join(self.tmpdirname      ,    VOCAB_FILES_NAMES['''emoji_file'''] )
  				with open(self.vocab_file      ,    '''w'''      ,    encoding='''utf-8''' ) as vocab_writer:
  							vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens] ) )
  				with open(self.emoji_file      ,    '''w''' ) as emoji_writer:
  							emoji_writer.write(json.dumps(lowercase ) )
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:Dict      ,    **lowercase			:Optional[int] )		->			int:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				kwargs.update(self.special_tokens_map )
  				return GPTNeoXJapaneseTokenizer.from_pretrained(self.tmpdirname      ,    **lowercase )
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:Dict      ,    lowercase			:Union[str, Any] )		->			List[str]:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				SCREAMING_SNAKE_CASE    	=   '''こんにちは、世界。 \nこんばんは、㔺界。😀'''
  				SCREAMING_SNAKE_CASE    	=   '''こんにちは、世界。 \nこんばんは、世界。😀'''
  				return input_text, output_text
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:Optional[int]      ,    lowercase			:Union[str, Any] )		->			List[str]:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				SCREAMING_SNAKE_CASE	,       SCREAMING_SNAKE_CASE    	=   self.get_input_output_texts(lowercase )
  				SCREAMING_SNAKE_CASE    	=   tokenizer.encode(lowercase      ,    add_special_tokens=lowercase )
  				SCREAMING_SNAKE_CASE    	=   tokenizer.decode(lowercase      ,    clean_up_tokenization_spaces=lowercase )
  				return text, ids
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:Dict )		->			int:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				pass  # TODO add if relevant
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:List[str] )		->			List[str]:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				pass  # TODO add if relevant
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:Optional[Any] )		->			Union[str, Any]:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				pass  # TODO add if relevant
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:Optional[Any] )		->			Dict:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				SCREAMING_SNAKE_CASE    	=   self.get_tokenizer()
  
  				# Testing tokenization
  				SCREAMING_SNAKE_CASE    	=   '''こんにちは、世界。　こんばんは、㔺界。'''
  				SCREAMING_SNAKE_CASE    	=   ['''こん''', '''にちは''', '''、''', '''世界''', '''。''', '''<SP>''', '''こん''', '''ばんは''', '''、''', '''㔺界''', '''。''']
  				SCREAMING_SNAKE_CASE    	=   tokenizer.tokenize(lowercase )
  				self.assertListEqual(lowercase      ,    lowercase )
  
  				# Testing conversion to ids without special tokens
  				SCREAMING_SNAKE_CASE    	=   [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6]
  				SCREAMING_SNAKE_CASE    	=   tokenizer.convert_tokens_to_ids(lowercase )
  				self.assertListEqual(lowercase      ,    lowercase )
  
  				# Testing conversion to ids with special tokens
  				SCREAMING_SNAKE_CASE    	=   tokens + [tokenizer.unk_token]
  				SCREAMING_SNAKE_CASE    	=   [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6, 1_9]
  				SCREAMING_SNAKE_CASE    	=   tokenizer.convert_tokens_to_ids(lowercase )
  				self.assertListEqual(lowercase      ,    lowercase )
  
  
  
  
  
  
  
  	@slow
  	def    snake_case__    (    self			:str )		->			Union[str, Any]:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				SCREAMING_SNAKE_CASE    	=   self.tokenizer_class.from_pretrained('''abeja/gpt-neox-japanese-2.7b''' )
  
  				SCREAMING_SNAKE_CASE    	=   tokenizer.encode('''ありがとう。'''      ,    add_special_tokens=lowercase )
  				SCREAMING_SNAKE_CASE    	=   tokenizer.encode('''どういたしまして。'''      ,    add_special_tokens=lowercase )
  
  				SCREAMING_SNAKE_CASE    	=   tokenizer.build_inputs_with_special_tokens(lowercase )
  				SCREAMING_SNAKE_CASE    	=   tokenizer.build_inputs_with_special_tokens(lowercase      ,    lowercase )
  
  				assert encoded_sentence == ids_a
  				assert encoded_pair == ids_a + ids_a
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:List[Any] )		->			Dict:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				pass
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:Any )		->			str:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				pass