code: 
  
  
  
  
  
  import argparse
  
  import torch
  
  from diffusers import UNetaDConditionModel
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__=None       ,lowerCAmelCase__=None       ,lowerCAmelCase__=None	):
  		assert isinstance(__A       ,__A	), "Paths should be a list of dicts containing 'old' and 'new' keys."
  
  		# Splits the attention layers into three variables.
  		if attention_paths_to_split is not None:
  				for path, path_map in attention_paths_to_split.items():
  						lowerCamelCase_  :    List[Any]   	=			old_checkpoint[path]
  						lowerCamelCase_  :    Optional[Any]   	=			old_tensor.shape[0] // 3
  
  						lowerCamelCase_  :    Any   	=			(-1, channels) if len(old_tensor.shape	) == 3 else (-1)
  
  						lowerCamelCase_  :    Any   	=			old_tensor.shape[0] // config['num_head_channels'] // 3
  
  						lowerCamelCase_  :    Union[str, Any]   	=			old_tensor.reshape((num_heads, 3 * channels // num_heads) + old_tensor.shape[1:]	)
  						lowerCamelCase_	,			lowerCamelCase_	,			lowerCamelCase_  :    int   	=			old_tensor.split(channels // num_heads       ,dim=1	)
  
  						lowerCamelCase_  :    List[Any]   	=			query.reshape(__A	)
  						lowerCamelCase_  :    Optional[Any]   	=			key.reshape(__A	)
  						lowerCamelCase_  :    Optional[int]   	=			value.reshape(__A	)
  
  		for path in paths:
  				lowerCamelCase_  :    Optional[Any]   	=			path['new']
  
  				# These have already been assigned
  				if attention_paths_to_split is not None and new_path in attention_paths_to_split:
  						continue
  
  				if additional_replacements is not None:
  						for replacement in additional_replacements:
  								lowerCamelCase_  :    Dict   	=			new_path.replace(replacement['old']       ,replacement['new']	)
  
  								    # proj_attn.weight has to be converted from conv 1D to linear
  				lowerCamelCase_  :    Tuple   	=			old_checkpoint[path['old']]
  				lowerCamelCase_  :    Dict   	=			['proj_attn.weight']
  				lowerCamelCase_  :    str   	=			['proj_out.weight', 'proj_in.weight']
  				if any(k in new_path for k in names	):
  						lowerCamelCase_  :    str   	=			weight[:, :, 0]
  				elif any(k in new_path for k in names_a	) and len(weight.shape	) > 2 and ".attentions." not in new_path:
  						lowerCamelCase_  :    Union[str, Any]   	=			weight[:, :, 0]
  				else:
  						lowerCamelCase_  :    Optional[Any]   	=			weight
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__=0	):
  		lowerCamelCase_  :    Tuple   	=			[]
  		for old_item in old_list:
  				lowerCamelCase_  :    Dict   	=			old_item
  
  				#         new_item = new_item.replace('norm.weight', 'group_norm.weight')
  				#         new_item = new_item.replace('norm.bias', 'group_norm.bias')
  
  				#         new_item = new_item.replace('proj_out.weight', 'proj_attn.weight')
  				#         new_item = new_item.replace('proj_out.bias', 'proj_attn.bias')
  
  				#         new_item = shave_segments(new_item, n_shave_prefix_segments=n_shave_prefix_segments)
  
  				mapping.append({'old': old_item, 'new': new_item}	)
  
  		return mapping
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__=1	):
  
  
  
  		if n_shave_prefix_segments >= 0:
  				return ".".join(path.split('.'	)[n_shave_prefix_segments:]	)
  		else:
  				return ".".join(path.split('.'	)[:n_shave_prefix_segments]	)
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__=0	):
  		lowerCamelCase_  :    Optional[Any]   	=			[]
  		for old_item in old_list:
  				mapping.append({'old': old_item, 'new': old_item}	)
  
  		return mapping
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__=0	):
  		lowerCamelCase_  :    List[Any]   	=			[]
  		for old_item in old_list:
  				lowerCamelCase_  :    List[Any]   	=			old_item.replace('in_layers.0'       ,'norm1'	)
  				lowerCamelCase_  :    Union[str, Any]   	=			new_item.replace('in_layers.2'       ,'conv1'	)
  
  				lowerCamelCase_  :    Optional[Any]   	=			new_item.replace('out_layers.0'       ,'norm2'	)
  				lowerCamelCase_  :    List[Any]   	=			new_item.replace('out_layers.3'       ,'conv2'	)
  
  				lowerCamelCase_  :    List[str]   	=			new_item.replace('emb_layers.1'       ,'time_emb_proj'	)
  				lowerCamelCase_  :    List[str]   	=			new_item.replace('skip_connection'       ,'conv_shortcut'	)
  
  				lowerCamelCase_  :    Union[str, Any]   	=			shave_segments(__A       ,n_shave_prefix_segments=__A	)
  
  				if "temopral_conv" not in old_item:
  						mapping.append({'old': old_item, 'new': new_item}	)
  
  		return mapping
  
  
  def 		_SCREAMING_SNAKE_CASE    (   lowerCAmelCase__       ,lowerCAmelCase__       ,lowerCAmelCase__=None       ,lowerCAmelCase__=False	):
  		lowerCamelCase_  :    int   	=			{}
  		lowerCamelCase_  :    List[Any]   	=			list(checkpoint.keys()	)
  
  		lowerCamelCase_  :    List[str]   	=			'model.diffusion_model.'
  
  		# at least a 100 parameters have to start with `model_ema` in order for the checkpoint to be EMA
  		if sum(k.startswith('model_ema'	) for k in keys	) > 1_00 and extract_ema:
  				print(F"Checkpoint {path} has both EMA and non-EMA weights."	)
  				print(
  				    'In this conversion only the EMA weights are extracted. If you want to instead extract the non-EMA'
  				    ' weights (useful to continue fine-tuning), please make sure to remove the `--extract_ema` flag.'	)
  				for key in keys:
  						if key.startswith('model.diffusion_model'	):
  								lowerCamelCase_  :    int   	=			'model_ema.' + ''.join(key.split('.'	)[1:]	)
  								lowerCamelCase_  :    int   	=			checkpoint.pop(__A	)
  		else:
  				if sum(k.startswith('model_ema'	) for k in keys	) > 1_00:
  						print(
  						    'In this conversion only the non-EMA weights are extracted. If you want to instead extract the EMA'
  						    ' weights (usually better for inference), please make sure to add the `--extract_ema` flag.'	)
  
  				for key in keys:
  						lowerCamelCase_  :    List[Any]   	=			checkpoint.pop(__A	)
  
  		lowerCamelCase_  :    List[Any]   	=			{}
  
  		lowerCamelCase_  :    Optional[Any]   	=			unet_state_dict['time_embed.0.weight']
  		lowerCamelCase_  :    Any   	=			unet_state_dict['time_embed.0.bias']
  		lowerCamelCase_  :    Optional[int]   	=			unet_state_dict['time_embed.2.weight']
  		lowerCamelCase_  :    str   	=			unet_state_dict['time_embed.2.bias']
  
  		if config["class_embed_type"] is None:
  				# No parameters to port
  				...
  		elif config["class_embed_type"] == "timestep" or config["class_embed_type"] == "projection":
  				lowerCamelCase_  :    Union[str, Any]   	=			unet_state_dict['label_emb.0.0.weight']
  				lowerCamelCase_  :    Optional[Any]   	=			unet_state_dict['label_emb.0.0.bias']
  				lowerCamelCase_  :    str   	=			unet_state_dict['label_emb.0.2.weight']
  				lowerCamelCase_  :    Any   	=			unet_state_dict['label_emb.0.2.bias']
  		else:
  				raise NotImplementedError(F"Not implemented `class_embed_type`: {config['class_embed_type']}"	)
  
  		lowerCamelCase_  :    List[Any]   	=			unet_state_dict['input_blocks.0.0.weight']
  		lowerCamelCase_  :    List[Any]   	=			unet_state_dict['input_blocks.0.0.bias']
  
  		lowerCamelCase_  :    List[str]   	=			[v for v in unet_state_dict if v.startswith('input_blocks.0.1'	)]
  		lowerCamelCase_  :    int   	=			renew_attention_paths(__A	)
  		lowerCamelCase_  :    Union[str, Any]   	=			{'old': 'input_blocks.0.1', 'new': 'transformer_in'}
  		assign_to_checkpoint(__A       ,__A       ,__A       ,additional_replacements=[meta_path]       ,config=__A	)
  
  		lowerCamelCase_  :    Optional[Any]   	=			unet_state_dict['out.0.weight']
  		lowerCamelCase_  :    List[str]   	=			unet_state_dict['out.0.bias']
  		lowerCamelCase_  :    str   	=			unet_state_dict['out.2.weight']
  		lowerCamelCase_  :    int   	=			unet_state_dict['out.2.bias']
  
  		# Retrieves the keys for the input blocks only
  		lowerCamelCase_  :    Optional[int]   	=			len({'.'.join(layer.split('.'	)[:2]	) for layer in unet_state_dict if 'input_blocks' in layer}	)
  		lowerCamelCase_  :    List[str]   	=			{
  		    layer_id: [key for key in unet_state_dict if F"input_blocks.{layer_id}" in key]
  		    for layer_id in range(__A	)
  		}
  
  		# Retrieves the keys for the middle blocks only
  		lowerCamelCase_  :    Optional[Any]   	=			len({'.'.join(layer.split('.'	)[:2]	) for layer in unet_state_dict if 'middle_block' in layer}	)
  		lowerCamelCase_  :    List[str]   	=			{
  		    layer_id: [key for key in unet_state_dict if F"middle_block.{layer_id}" in key]
  		    for layer_id in range(__A	)
  		}
  
  		# Retrieves the keys for the output blocks only
  		lowerCamelCase_  :    Any   	=			len({'.'.join(layer.split('.'	)[:2]	) for layer in unet_state_dict if 'output_blocks' in layer}	)
  		lowerCamelCase_  :    Optional[Any]   	=			{
  		    layer_id: [key for key in unet_state_dict if F"output_blocks.{layer_id}" in key]
  		    for layer_id in range(__A	)
  		}
  
  		for i in range(1       ,__A	):
  				lowerCamelCase_  :    Tuple   	=			(i - 1) // (config['layers_per_block'] + 1)
  				lowerCamelCase_  :    Tuple   	=			(i - 1) % (config['layers_per_block'] + 1)
  
  				lowerCamelCase_  :    List[str]   	=			[
  				    key for key in input_blocks[i] if F"input_blocks.{i}.0" in key and F"input_blocks.{i}.0.op" not in key
  				]
  				lowerCamelCase_  :    List[Any]   	=			[key for key in input_blocks[i] if F"input_blocks.{i}.1" in key]
  				lowerCamelCase_  :    str   	=			[key for key in input_blocks[i] if F"input_blocks.{i}.2" in key]
  
  				if F"input_blocks.{i}.op.weight" in unet_state_dict:
  						lowerCamelCase_  :    Optional[Any]   	=			unet_state_dict.pop(
  						    F"input_blocks.{i}.op.weight"	)
  						lowerCamelCase_  :    Optional[Any]   	=			unet_state_dict.pop(
  						    F"input_blocks.{i}.op.bias"	)
  
  				lowerCamelCase_  :    Optional[Any]   	=			renew_resnet_paths(__A	)
  				lowerCamelCase_  :    Dict   	=			{'old': F"input_blocks.{i}.0", 'new': F"down_blocks.{block_id}.resnets.{layer_in_block_id}"}
  				assign_to_checkpoint(
  				    __A       ,__A       ,__A       ,additional_replacements=[meta_path]       ,config=__A	)
  
  				lowerCamelCase_  :    int   	=			[key for key in resnets if 'temopral_conv' in key]
  				lowerCamelCase_  :    Optional[int]   	=			renew_temp_conv_paths(__A	)
  				lowerCamelCase_  :    int   	=			{
  				    'old': F"input_blocks.{i}.0.temopral_conv",
  				    'new': F"down_blocks.{block_id}.temp_convs.{layer_in_block_id}",
  				}
  				assign_to_checkpoint(
  				    __A       ,__A       ,__A       ,additional_replacements=[meta_path]       ,config=__A	)
  
  				if len(__A	):
  						lowerCamelCase_  :    Optional[int]   	=			renew_attention_paths(__A	)
  						lowerCamelCase_  :    Dict   	=			{'old': F"input_blocks.{i}.1", 'new': F"down_blocks.{block_id}.attentions.{layer_in_block_id}"}
  						assign_to_checkpoint(
  						    __A       ,__A       ,__A       ,additional_replacements=[meta_path]       ,config=__A	)
  
  				if len(__A	):
  						lowerCamelCase_  :    Any   	=			renew_attention_paths(__A	)
  						lowerCamelCase_  :    Optional[Any]   	=			{
  						    'old': F"input_blocks.{i}.2",
  						    'new': F"down_blocks.{block_id}.temp_attentions.{layer_in_block_id}",
  						}
  						assign_to_checkpoint(
  						    __A       ,__A       ,__A       ,additional_replacements=[meta_path]       ,config=__A	)
  
  		lowerCamelCase_  :    Any   	=			middle_blocks[0]
  		lowerCamelCase_  :    int   	=			[key for key in resnet_a if 'temopral_conv' in key]
  		lowerCamelCase_  :    Tuple   	=			middle_blocks[1]
  		lowerCamelCase_  :    Dict   	=			middle_blocks[2]
  		lowerCamelCase_  :    List[Any]   	=			middle_blocks[3]
  		lowerCamelCase_  :    Union[str, Any]   	=			[key for key in resnet_a if 'temopral_conv' in key]
  
  		lowerCamelCase_  :    Optional[Any]   	=			renew_resnet_paths(__A	)
  		lowerCamelCase_  :    str   	=			{'old': 'middle_block.0', 'new': 'mid_block.resnets.0'}
  		assign_to_checkpoint(
  		    __A       ,__A       ,__A       ,config=__A       ,additional_replacements=[meta_path]	)
  
  		lowerCamelCase_  :    Tuple   	=			renew_temp_conv_paths(__A	)
  		lowerCamelCase_  :    str   	=			{'old': 'middle_block.0.temopral_conv', 'new': 'mid_block.temp_convs.0'}
  		assign_to_checkpoint(
  		    __A       ,__A       ,__A       ,config=__A       ,additional_replacements=[meta_path]	)
  
  		lowerCamelCase_  :    List[Any]   	=			renew_resnet_paths(__A	)
  		lowerCamelCase_  :    int   	=			{'old': 'middle_block.3', 'new': 'mid_block.resnets.1'}
  		assign_to_checkpoint(
  		    __A       ,__A       ,__A       ,config=__A       ,additional_replacements=[meta_path]	)
  
  		lowerCamelCase_  :    List[str]   	=			renew_temp_conv_paths(__A	)
  		lowerCamelCase_  :    Any   	=			{'old': 'middle_block.3.temopral_conv', 'new': 'mid_block.temp_convs.1'}
  		assign_to_checkpoint(
  		    __A       ,__A       ,__A       ,config=__A       ,additional_replacements=[meta_path]	)
  
  		lowerCamelCase_  :    List[Any]   	=			renew_attention_paths(__A	)
  		lowerCamelCase_  :    int   	=			{'old': 'middle_block.1', 'new': 'mid_block.attentions.0'}
  		assign_to_checkpoint(
  		    __A       ,__A       ,__A       ,additional_replacements=[meta_path]       ,config=__A	)
  
  		lowerCamelCase_  :    str   	=			renew_attention_paths(__A	)
  		lowerCamelCase_  :    Tuple   	=			{'old': 'middle_block.2', 'new': 'mid_block.temp_attentions.0'}
  		assign_to_checkpoint(
  		    __A       ,__A       ,__A       ,additional_replacements=[meta_path]       ,config=__A	)
  
  		for i in range(__A	):
  				lowerCamelCase_  :    List[Any]   	=			i // (config['layers_per_block'] + 1)
  				lowerCamelCase_  :    str   	=			i % (config['layers_per_block'] + 1)
  				lowerCamelCase_  :    str   	=			[shave_segments(__A       ,2	) for name in output_blocks[i]]
  				lowerCamelCase_  :    List[str]   	=			{}
  
  				for layer in output_block_layers:
  						lowerCamelCase_	,			lowerCamelCase_  :    str   	=			layer.split('.'	)[0], shave_segments(__A       ,1	)
  						if layer_id in output_block_list:
  								output_block_list[layer_id].append(__A	)
  						else:
  								lowerCamelCase_  :    Tuple   	=			[layer_name]
  
  				if len(__A	) > 1:
  						lowerCamelCase_  :    Dict   	=			[key for key in output_blocks[i] if F"output_blocks.{i}.0" in key]
  						lowerCamelCase_  :    List[Any]   	=			[key for key in output_blocks[i] if F"output_blocks.{i}.1" in key]
  						lowerCamelCase_  :    Any   	=			[key for key in output_blocks[i] if F"output_blocks.{i}.2" in key]
  
  						lowerCamelCase_  :    Optional[int]   	=			renew_resnet_paths(__A	)
  						lowerCamelCase_  :    Dict   	=			renew_resnet_paths(__A	)
  
  						lowerCamelCase_  :    Dict   	=			{'old': F"output_blocks.{i}.0", 'new': F"up_blocks.{block_id}.resnets.{layer_in_block_id}"}
  						assign_to_checkpoint(
  						    __A       ,__A       ,__A       ,additional_replacements=[meta_path]       ,config=__A	)
  
  						lowerCamelCase_  :    Any   	=			[key for key in resnets if 'temopral_conv' in key]
  						lowerCamelCase_  :    List[Any]   	=			renew_temp_conv_paths(__A	)
  						lowerCamelCase_  :    List[str]   	=			{
  						    'old': F"output_blocks.{i}.0.temopral_conv",
  						    'new': F"up_blocks.{block_id}.temp_convs.{layer_in_block_id}",
  						}
  						assign_to_checkpoint(
  						    __A       ,__A       ,__A       ,additional_replacements=[meta_path]       ,config=__A	)
  
  						lowerCamelCase_  :    Optional[int]   	=			{k: sorted(__A	) for k, v in output_block_list.items()}
  						if ["conv.bias", "conv.weight"] in output_block_list.values():
  								lowerCamelCase_  :    Any   	=			list(output_block_list.values()	).index(['conv.bias', 'conv.weight']	)
  								lowerCamelCase_  :    Any   	=			unet_state_dict[
  								    F"output_blocks.{i}.{index}.conv.weight"
  								]
  								lowerCamelCase_  :    int   	=			unet_state_dict[
  								    F"output_blocks.{i}.{index}.conv.bias"
  								]
  
  								# Clear attentions as they have been attributed above.
  								if len(__A	) == 2:
  										lowerCamelCase_  :    Union[str, Any]   	=			[]
  
  						if len(__A	):
  								lowerCamelCase_  :    Any   	=			renew_attention_paths(__A	)
  								lowerCamelCase_  :    Optional[int]   	=			{
  								    'old': F"output_blocks.{i}.1",
  								    'new': F"up_blocks.{block_id}.attentions.{layer_in_block_id}",
  								}
  								assign_to_checkpoint(
  								    __A       ,__A       ,__A       ,additional_replacements=[meta_path]       ,config=__A	)
  
  						if len(__A	):
  								lowerCamelCase_  :    int   	=			renew_attention_paths(__A	)
  								lowerCamelCase_  :    int   	=			{
  								    'old': F"output_blocks.{i}.2",
  								    'new': F"up_blocks.{block_id}.temp_attentions.{layer_in_block_id}",
  								}
  								assign_to_checkpoint(
  								    __A       ,__A       ,__A       ,additional_replacements=[meta_path]       ,config=__A	)
  				else:
  						lowerCamelCase_  :    int   	=			renew_resnet_paths(__A       ,n_shave_prefix_segments=1	)
  						for path in resnet_0_paths:
  								lowerCamelCase_  :    List[str]   	=			'.'.join(['output_blocks', str(__A	), path['old']]	)
  								lowerCamelCase_  :    Optional[int]   	=			'.'.join(['up_blocks', str(__A	), 'resnets', str(__A	), path['new']]	)
  								lowerCamelCase_  :    List[Any]   	=			unet_state_dict[old_path]
  
  						lowerCamelCase_  :    List[str]   	=			[l for l in output_block_layers if 'temopral_conv' in l]
  						for path in temopral_conv_paths:
  								lowerCamelCase_  :    str   	=			path.split('temopral_conv.'	)[-1]
  								lowerCamelCase_  :    int   	=			'.'.join(['output_blocks', str(__A	), str(__A	), 'temopral_conv', pruned_path]	)
  								lowerCamelCase_  :    int   	=			'.'.join(['up_blocks', str(__A	), 'temp_convs', str(__A	), pruned_path]	)
  								lowerCamelCase_  :    Tuple   	=			unet_state_dict[old_path]
  
  		return new_checkpoint
  
  
  if __name__ == "__main__":
  		_lowercase		:     str 					=argparse.ArgumentParser()
  
  		parser.add_argument(
  		    """--checkpoint_path""", default=None, type=str, required=True, help="""Path to the checkpoint to convert."""
  		)
  		parser.add_argument("""--dump_path""", default=None, type=str, required=True, help="""Path to the output model.""")
  		_lowercase		:     List[Any] 					=parser.parse_args()
  
  		_lowercase		:     int 					=torch.load(args.checkpoint_path, map_location="""cpu""")
  		_lowercase		:     int 					=UNetaDConditionModel()
  
  		_lowercase		:     List[str] 					=convert_ldm_unet_checkpoint(unet_checkpoint, unet.config)
  
  		_lowercase		:     List[Any] 					=set(unet.state_dict().keys()) - set(converted_ckpt.keys())
  		_lowercase		:     List[str] 					=set(converted_ckpt.keys()) - set(unet.state_dict().keys())
  
  		assert len(diff_a) == len(diff_a) == 0, "Converted weights don't match"
  
  		# load state_dict
  		unet.load_state_dict(converted_ckpt)
  
  		unet.save_pretrained(args.dump_path)
  
  		# -- finish converting the unet --
  
  
  
style_context: 
  
  
  
  
  
  from ...configuration_utils import PretrainedConfig
  from ...utils import logging
  
  
  _lowercase		:     Dict 					=logging.get_logger(__name__)
  
  _lowercase		:     Any 					={
      """dandelin/vilt-b32-mlm""": """https://huggingface.co/dandelin/vilt-b32-mlm/blob/main/config.json"""
  }
  
  
  
  
  
  
  class 	UpperCamelCase_     (     snake_case__       ):
  					_a			:	List[str]							=				'vilt'
  
  
  
  					def __init__(		self    :    int					,			lowerCamelCase    :    Any=3_05_22					,			lowerCamelCase    :    Union[str, Any]=2					,			lowerCamelCase    :    Optional[Any]=2					,			lowerCamelCase    :    str=40					,			lowerCamelCase    :    List[str]=7_68					,			lowerCamelCase    :    Optional[int]=12					,			lowerCamelCase    :    List[Any]=12					,			lowerCamelCase    :    List[str]=30_72					,			lowerCamelCase    :    Union[str, Any]="gelu"					,			lowerCamelCase    :    int=0.0					,			lowerCamelCase    :    str=0.0					,			lowerCamelCase    :    int=0.02					,			lowerCamelCase    :    Union[str, Any]=1E-12					,			lowerCamelCase    :    Dict=3_84					,			lowerCamelCase    :    List[str]=32					,			lowerCamelCase    :    Dict=3					,			lowerCamelCase    :    List[str]=True					,			lowerCamelCase    :    int=-1					,			lowerCamelCase    :    List[Any]=False					,			lowerCamelCase    :    Any=-1					,			**lowerCamelCase    :    str					,			):
  							super().__init__(tie_word_embeddings=lowerCamelCase					,			**lowerCamelCase	)
  
  							lowerCamelCase_  :    str   	=			vocab_size
  							lowerCamelCase_  :    Dict   	=			type_vocab_size
  							lowerCamelCase_  :    str   	=			modality_type_vocab_size
  							lowerCamelCase_  :    Optional[Any]   	=			max_position_embeddings
  
  							lowerCamelCase_  :    List[Any]   	=			hidden_size
  							lowerCamelCase_  :    Union[str, Any]   	=			num_hidden_layers
  							lowerCamelCase_  :    Any   	=			num_attention_heads
  							lowerCamelCase_  :    List[Any]   	=			intermediate_size
  							lowerCamelCase_  :    Union[str, Any]   	=			hidden_act
  							lowerCamelCase_  :    Any   	=			hidden_dropout_prob
  							lowerCamelCase_  :    Optional[int]   	=			attention_probs_dropout_prob
  							lowerCamelCase_  :    Any   	=			initializer_range
  							lowerCamelCase_  :    str   	=			layer_norm_eps
  
  							lowerCamelCase_  :    Optional[Any]   	=			image_size
  							lowerCamelCase_  :    List[Any]   	=			patch_size
  							lowerCamelCase_  :    Tuple   	=			num_channels
  							lowerCamelCase_  :    Optional[Any]   	=			qkv_bias
  							lowerCamelCase_  :    Optional[int]   	=			max_image_length
  							lowerCamelCase_  :    Optional[Any]   	=			num_images
  