



'''simple docstring'''




import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import cached_download, hf_hub_download, hf_hub_url
from PIL import Image

from transformers import DetaConfig, DetaForObjectDetection, DetaImageProcessor, SwinConfig
from transformers.utils import logging


logging.set_verbosity_info()
lowerCamelCase							:Union[str, Any]				    =					logging.get_logger(__name__)



def 	a			( lowerCamelCase__    ):
			'''simple docstring'''





			A_	:						str	=     SwinConfig(
			    embed_dim=1_92						,      depths=(2, 2, 18, 2)						,      num_heads=(6, 12, 24, 48)						,      window_size=12						,      out_features=["""stage2""", """stage3""", """stage4"""]						,      )

			A_	:						Union[str, Any]	=     DetaConfig(
			    backbone_config=lowerCamelCase__						,      num_queries=9_00						,      encoder_ffn_dim=20_48						,      decoder_ffn_dim=20_48						,      num_feature_levels=5						,      assign_first_stage=lowerCamelCase__						,      with_box_refine=lowerCamelCase__						,      two_stage=lowerCamelCase__						,      )

			# set labels
			A_	:						Union[str, Any]	=     """huggingface/label-files"""
			if "o365" in model_name:
						A_	:						List[Any]	=     3_66
						A_	:						str	=     """object365-id2label.json"""
			else:
						A_	:						int	=     91
						A_	:						Optional[Any]	=     """coco-detection-id2label.json"""

			A_	:						Dict	=     num_labels
			A_	:						str	=     json.load(open(cached_download(hf_hub_url(lowerCamelCase__						,      lowerCamelCase__						,      repo_type="""dataset"""    )    )						,      """r"""    )    )
			A_	:						Tuple	=     {int(lowerCamelCase__    ): v for k, v in idalabel.items()}
			A_	:						int	=     idalabel
			A_	:						Any	=     {v: k for k, v in idalabel.items()}

			return config



def 	a			( lowerCamelCase__    ):
			'''simple docstring'''





			A_	:						Dict	=     []

			# stem
			# fmt: off
			rename_keys.append(("""backbone.0.body.patch_embed.proj.weight""", """model.backbone.model.embeddings.patch_embeddings.projection.weight""")    )
			rename_keys.append(("""backbone.0.body.patch_embed.proj.bias""", """model.backbone.model.embeddings.patch_embeddings.projection.bias""")    )
			rename_keys.append(("""backbone.0.body.patch_embed.norm.weight""", """model.backbone.model.embeddings.norm.weight""")    )
			rename_keys.append(("""backbone.0.body.patch_embed.norm.bias""", """model.backbone.model.embeddings.norm.bias""")    )
			# stages
			for i in range(len(config.backbone_config.depths    )    ):
						for j in range(config.backbone_config.depths[i]    ):
									rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.norm1.weight', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight')    )
									rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.norm1.bias', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias')    )
									rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_bias_table', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table')    )
									rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_index', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index')    )
									rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.attn.proj.weight', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight')    )
									rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.attn.proj.bias', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias')    )
									rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.norm2.weight', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight')    )
									rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.norm2.bias', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias')    )
									rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.weight', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight')    )
									rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.bias', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias')    )
									rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.weight', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.weight')    )
									rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.bias', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.bias')    )

						if i < 3:
									rename_keys.append((f'backbone.0.body.layers.{i}.downsample.reduction.weight', f'model.backbone.model.encoder.layers.{i}.downsample.reduction.weight')    )
									rename_keys.append((f'backbone.0.body.layers.{i}.downsample.norm.weight', f'model.backbone.model.encoder.layers.{i}.downsample.norm.weight')    )
									rename_keys.append((f'backbone.0.body.layers.{i}.downsample.norm.bias', f'model.backbone.model.encoder.layers.{i}.downsample.norm.bias')    )

			rename_keys.append(("""backbone.0.body.norm1.weight""", """model.backbone.model.hidden_states_norms.stage2.weight""")    )
			rename_keys.append(("""backbone.0.body.norm1.bias""", """model.backbone.model.hidden_states_norms.stage2.bias""")    )
			rename_keys.append(("""backbone.0.body.norm2.weight""", """model.backbone.model.hidden_states_norms.stage3.weight""")    )
			rename_keys.append(("""backbone.0.body.norm2.bias""", """model.backbone.model.hidden_states_norms.stage3.bias""")    )
			rename_keys.append(("""backbone.0.body.norm3.weight""", """model.backbone.model.hidden_states_norms.stage4.weight""")    )
			rename_keys.append(("""backbone.0.body.norm3.bias""", """model.backbone.model.hidden_states_norms.stage4.bias""")    )

			# transformer encoder
			for i in range(config.encoder_layers    ):
						rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.sampling_offsets.weight', f'model.encoder.layers.{i}.self_attn.sampling_offsets.weight')    )
						rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.sampling_offsets.bias', f'model.encoder.layers.{i}.self_attn.sampling_offsets.bias')    )
						rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.attention_weights.weight', f'model.encoder.layers.{i}.self_attn.attention_weights.weight')    )
						rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.attention_weights.bias', f'model.encoder.layers.{i}.self_attn.attention_weights.bias')    )
						rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.value_proj.weight', f'model.encoder.layers.{i}.self_attn.value_proj.weight')    )
						rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.value_proj.bias', f'model.encoder.layers.{i}.self_attn.value_proj.bias')    )
						rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.output_proj.weight', f'model.encoder.layers.{i}.self_attn.output_proj.weight')    )
						rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.output_proj.bias', f'model.encoder.layers.{i}.self_attn.output_proj.bias')    )
						rename_keys.append((f'transformer.encoder.layers.{i}.norm1.weight', f'model.encoder.layers.{i}.self_attn_layer_norm.weight')    )
						rename_keys.append((f'transformer.encoder.layers.{i}.norm1.bias', f'model.encoder.layers.{i}.self_attn_layer_norm.bias')    )
						rename_keys.append((f'transformer.encoder.layers.{i}.linear1.weight', f'model.encoder.layers.{i}.fc1.weight')    )
						rename_keys.append((f'transformer.encoder.layers.{i}.linear1.bias', f'model.encoder.layers.{i}.fc1.bias')    )
						rename_keys.append((f'transformer.encoder.layers.{i}.linear2.weight', f'model.encoder.layers.{i}.fc2.weight')    )
						rename_keys.append((f'transformer.encoder.layers.{i}.linear2.bias', f'model.encoder.layers.{i}.fc2.bias')    )
						rename_keys.append((f'transformer.encoder.layers.{i}.norm2.weight', f'model.encoder.layers.{i}.final_layer_norm.weight')    )
						rename_keys.append((f'transformer.encoder.layers.{i}.norm2.bias', f'model.encoder.layers.{i}.final_layer_norm.bias')    )

			# transformer decoder
			for i in range(config.decoder_layers    ):
						rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.sampling_offsets.weight', f'model.decoder.layers.{i}.encoder_attn.sampling_offsets.weight')    )
						rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.sampling_offsets.bias', f'model.decoder.layers.{i}.encoder_attn.sampling_offsets.bias')    )
						rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.attention_weights.weight', f'model.decoder.layers.{i}.encoder_attn.attention_weights.weight')    )
						rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.attention_weights.bias', f'model.decoder.layers.{i}.encoder_attn.attention_weights.bias')    )
						rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.value_proj.weight', f'model.decoder.layers.{i}.encoder_attn.value_proj.weight')    )
						rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.value_proj.bias', f'model.decoder.layers.{i}.encoder_attn.value_proj.bias')    )
						rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.output_proj.weight', f'model.decoder.layers.{i}.encoder_attn.output_proj.weight')    )
						rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.output_proj.bias', f'model.decoder.layers.{i}.encoder_attn.output_proj.bias')    )
						rename_keys.append((f'transformer.decoder.layers.{i}.norm1.weight', f'model.decoder.layers.{i}.encoder_attn_layer_norm.weight')    )
						rename_keys.append((f'transformer.decoder.layers.{i}.norm1.bias', f'model.decoder.layers.{i}.encoder_attn_layer_norm.bias')    )
						rename_keys.append((f'transformer.decoder.layers.{i}.self_attn.out_proj.weight', f'model.decoder.layers.{i}.self_attn.out_proj.weight')    )
						rename_keys.append((f'transformer.decoder.layers.{i}.self_attn.out_proj.bias', f'model.decoder.layers.{i}.self_attn.out_proj.bias')    )
						rename_keys.append((f'transformer.decoder.layers.{i}.norm2.weight', f'model.decoder.layers.{i}.self_attn_layer_norm.weight')    )
						rename_keys.append((f'transformer.decoder.layers.{i}.norm2.bias', f'model.decoder.layers.{i}.self_attn_layer_norm.bias')    )
						rename_keys.append((f'transformer.decoder.layers.{i}.linear1.weight', f'model.decoder.layers.{i}.fc1.weight')    )
						rename_keys.append((f'transformer.decoder.layers.{i}.linear1.bias', f'model.decoder.layers.{i}.fc1.bias')    )
						rename_keys.append((f'transformer.decoder.layers.{i}.linear2.weight', f'model.decoder.layers.{i}.fc2.weight')    )
						rename_keys.append((f'transformer.decoder.layers.{i}.linear2.bias', f'model.decoder.layers.{i}.fc2.bias')    )
						rename_keys.append((f'transformer.decoder.layers.{i}.norm3.weight', f'model.decoder.layers.{i}.final_layer_norm.weight')    )
						rename_keys.append((f'transformer.decoder.layers.{i}.norm3.bias', f'model.decoder.layers.{i}.final_layer_norm.bias')    )

			# fmt: on

			return rename_keys



def 	a			( lowerCamelCase__						,      lowerCamelCase__						,      lowerCamelCase__    ):
			'''simple docstring'''





			A_	:						List[Any]	=     dct.pop(lowerCamelCase__    )
			A_	:						Optional[Any]	=     val



def 	a			( lowerCamelCase__						,      lowerCamelCase__    ):
			'''simple docstring'''





			A_	:						Optional[int]	=     [int(backbone_config.embed_dim * 2**i    ) for i in range(len(backbone_config.depths    )    )]
			for i in range(len(backbone_config.depths    )    ):
						A_	:						Union[str, Any]	=     num_features[i]
						for j in range(backbone_config.depths[i]    ):
									# fmt: off
									# read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
									A_	:						int	=     state_dict.pop(f'backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.weight'    )
									A_	:						str	=     state_dict.pop(f'backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.bias'    )
									# next, add query, keys and values (in that order) to the state dict
									A_	:						Any	=     in_proj_weight[:dim, :]
									A_	:						Tuple	=     in_proj_bias[: dim]
									A_	:						int	=     in_proj_weight[
									    dim : dim * 2, :
									]
									A_	:						Union[str, Any]	=     in_proj_bias[
									    dim : dim * 2
									]
									A_	:						Union[str, Any]	=     in_proj_weight[
									    -dim :, :
									]
									A_	:						Union[str, Any]	=     in_proj_bias[-dim :]
									# fmt: on



def 	a			( lowerCamelCase__						,      lowerCamelCase__    ):
			'''simple docstring'''





			A_	:						Union[str, Any]	=     config.d_model
			for i in range(config.decoder_layers    ):
						# read in weights + bias of input projection layer of self-attention
						A_	:						List[Any]	=     state_dict.pop(f'transformer.decoder.layers.{i}.self_attn.in_proj_weight'    )
						A_	:						Optional[Any]	=     state_dict.pop(f'transformer.decoder.layers.{i}.self_attn.in_proj_bias'    )
						# next, add query, keys and values (in that order) to the state dict
						A_	:						List[Any]	=     in_proj_weight[:hidden_size, :]
						A_	:						Any	=     in_proj_bias[:hidden_size]
						A_	:						List[Any]	=     in_proj_weight[
						    hidden_size : hidden_size * 2, :
						]
						A_	:						str	=     in_proj_bias[hidden_size : hidden_size * 2]
						A_	:						Dict	=     in_proj_weight[-hidden_size:, :]
						A_	:						List[Any]	=     in_proj_bias[-hidden_size:]



def 	a			( ):
			'''simple docstring'''





			A_	:						List[str]	=     """http://images.cocodataset.org/val2017/000000039769.jpg"""
			A_	:						List[Any]	=     Image.open(requests.get(lowerCamelCase__						,      stream=lowerCamelCase__    ).raw    )

			return im



@torch.no_grad()
def 	a			( lowerCamelCase__						,      lowerCamelCase__						,      lowerCamelCase__    ):
			'''simple docstring'''





			A_	:						int	=     get_deta_config(lowerCamelCase__    )

			# load original state dict
			if model_name == "deta-swin-large":
						A_	:						Optional[Any]	=     hf_hub_download(repo_id="""nielsr/deta-checkpoints"""						,      filename="""adet_swin_ft.pth"""    )
			elif model_name == "deta-swin-large-o365":
						A_	:						Union[str, Any]	=     hf_hub_download(repo_id="""jozhang97/deta-swin-l-o365"""						,      filename="""deta_swin_pt_o365.pth"""    )
			else:
						raise ValueError(f'Model name {model_name} not supported'    )

			A_	:						Dict	=     torch.load(lowerCamelCase__						,      map_location="""cpu"""    )["""model"""]

			# original state dict
			for name, param in state_dict.items():
						print(lowerCamelCase__						,      param.shape    )

			# rename keys
			A_	:						List[str]	=     create_rename_keys(lowerCamelCase__    )
			for src, dest in rename_keys:
						rename_key(lowerCamelCase__						,      lowerCamelCase__						,      lowerCamelCase__    )
			read_in_swin_q_k_v(lowerCamelCase__						,      config.backbone_config    )
			read_in_decoder_q_k_v(lowerCamelCase__						,      lowerCamelCase__    )

			# fix some prefixes
			for key in state_dict.copy().keys():
						if "transformer.decoder.class_embed" in key or "transformer.decoder.bbox_embed" in key:
									A_	:						Dict	=     state_dict.pop(lowerCamelCase__    )
									A_	:						Dict	=     val
						if "input_proj" in key:
									A_	:						List[Any]	=     state_dict.pop(lowerCamelCase__    )
									A_	:						Optional[int]	=     val
						if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
									A_	:						Optional[int]	=     state_dict.pop(lowerCamelCase__    )
									A_	:						Tuple	=     val

    # finally, create HuggingFace model and load state dict
			A_	:						List[str]	=     DetaForObjectDetection(lowerCamelCase__    )
			model.load_state_dict(lowerCamelCase__    )
			model.eval()

			A_	:						List[Any]	=     """cuda""" if torch.cuda.is_available() else """cpu"""
			model.to(lowerCamelCase__    )

			# load image processor
			A_	:						Dict	=     DetaImageProcessor(format="""coco_detection"""    )

			# verify our conversion on image
			A_	:						List[str]	=     prepare_img()
			A_	:						List[Any]	=     processor(images=lowerCamelCase__						,      return_tensors="""pt"""    )
			A_	:						int	=     encoding["""pixel_values"""]
			A_	:						Optional[Any]	=     model(pixel_values.to(lowerCamelCase__    )    )

			# verify logits
			print("""Logits:"""						,      outputs.logits[0, :3, :3]    )
			print("""Boxes:"""						,      outputs.pred_boxes[0, :3, :3]    )
			if model_name == "deta-swin-large":
						A_	:						str	=     torch.tensor(
						    [[-7.6_308, -2.8_485, -5.3_737], [-7.2_037, -4.5_505, -4.8_027], [-7.2_943, -4.2_611, -4.6_617]]    )
						A_	:						List[str]	=     torch.tensor([[0.4_987, 0.4_969, 0.9_999], [0.2_549, 0.5_498, 0.4_805], [0.5_498, 0.2_757, 0.0_569]]    )
			elif model_name == "deta-swin-large-o365":
						A_	:						Dict	=     torch.tensor(
						    [[-8.0_122, -3.5_720, -4.9_717], [-8.1_547, -3.6_886, -4.6_389], [-7.6_610, -3.6_194, -5.0_134]]    )
						A_	:						Union[str, Any]	=     torch.tensor([[0.2_523, 0.5_549, 0.4_881], [0.7_715, 0.4_149, 0.4_601], [0.5_503, 0.2_753, 0.0_575]]    )
			assert torch.allclose(outputs.logits[0, :3, :3]						,      expected_logits.to(lowerCamelCase__    )						,      atol=1E-4    )
			assert torch.allclose(outputs.pred_boxes[0, :3, :3]						,      expected_boxes.to(lowerCamelCase__    )						,      atol=1E-4    )
			print("""Everything ok!"""    )

			if pytorch_dump_folder_path:
						# Save model and processor
						logger.info(f'Saving PyTorch model and processor to {pytorch_dump_folder_path}...'    )
						Path(lowerCamelCase__    ).mkdir(exist_ok=lowerCamelCase__    )
						model.save_pretrained(lowerCamelCase__    )
						processor.save_pretrained(lowerCamelCase__    )

			# Push to hub
			if push_to_hub:
						print("""Pushing model and processor to hub..."""    )
						model.push_to_hub(f'jozhang97/{model_name}'    )
						processor.push_to_hub(f'jozhang97/{model_name}'    )


if __name__ == "__main__":
						lowerCamelCase							:Tuple				    =					argparse.ArgumentParser()

						parser.add_argument(
						    '''--model_name''',
						    type=str,
						    default='''deta-swin-large''',
						    choices=['''deta-swin-large''', '''deta-swin-large-o365'''],
						    help='''Name of the model you\'d like to convert.''',
						)
						parser.add_argument(
						    '''--pytorch_dump_folder_path''',
						    default=None,
						    type=str,
						    help='''Path to the folder to output PyTorch model.''',
						)
						parser.add_argument(
						    '''--push_to_hub''', action='''store_true''', help='''Whether or not to push the converted model to the 🤗 hub.'''
						)
						lowerCamelCase							:List[Any]				    =					parser.parse_args()
						convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)




'''simple docstring'''




from typing import List, Optional, Union

from ...image_utils import ImageInput
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType







class 	_lowerCAmelCase							(			__UpperCAmelCase ):
	__SCREAMING_SNAKE_CASE   :		Any					=					['image_processor', 'tokenizer']
	__SCREAMING_SNAKE_CASE   :		Union[str, Any]					=					'BlipImageProcessor'
	__SCREAMING_SNAKE_CASE   :		List[Any]					=					('BertTokenizer', 'BertTokenizerFast')


	def __init__(self       ,      lowercase       ,      lowercase							):
				A_	:						List[Any]	=     False
				super().__init__(lowercase       ,      lowercase							)
				A_	:						Tuple	=     self.image_processor


	def __call__(self       ,      lowercase = None       ,      lowercase = None       ,      lowercase = True       ,      lowercase = False       ,      lowercase = None       ,      lowercase = None       ,      lowercase = 0       ,      lowercase = None       ,      lowercase = None       ,      lowercase = False       ,      lowercase = False       ,      lowercase = False       ,      lowercase = False       ,      lowercase = False       ,      lowercase = True       ,      lowercase = None       ,      **lowercase       ,      ):
				if images is None and text is None:
							raise ValueError("""You have to specify either images or text."""							)

				# Get only text
				if images is None:
							A_	:						Optional[Any]	=     self.tokenizer
							A_	:						Tuple	=     self.tokenizer(
							    text=lowercase       ,      add_special_tokens=lowercase       ,      padding=lowercase       ,      truncation=lowercase       ,      max_length=lowercase       ,      stride=lowercase       ,      pad_to_multiple_of=lowercase       ,      return_attention_mask=lowercase       ,      return_overflowing_tokens=lowercase       ,      return_special_tokens_mask=lowercase       ,      return_offsets_mapping=lowercase       ,      return_token_type_ids=lowercase       ,      return_length=lowercase       ,      verbose=lowercase       ,      return_tensors=lowercase       ,      **lowercase       ,      )
							return text_encoding

				# add pixel_values
				A_	:						int	=     self.image_processor(lowercase       ,      return_tensors=lowercase							)

				if text is not None:
							A_	:						Optional[Any]	=     self.tokenizer(
							    text=lowercase       ,      add_special_tokens=lowercase       ,      padding=lowercase       ,      truncation=lowercase       ,      max_length=lowercase       ,      stride=lowercase       ,      pad_to_multiple_of=lowercase       ,      return_attention_mask=lowercase       ,      return_overflowing_tokens=lowercase       ,      return_special_tokens_mask=lowercase       ,      return_offsets_mapping=lowercase       ,      return_token_type_ids=lowercase       ,      return_length=lowercase       ,      verbose=lowercase       ,      return_tensors=lowercase       ,      **lowercase       ,      )
				else:
							A_	:						List[str]	=     None

				if text_encoding is not None:
							encoding_image_processor.update(lowercase							)

				return encoding_image_processor


	def     _a	(self       ,      *lowercase       ,      **lowercase							):
				return self.tokenizer.batch_decode(*lowercase       ,      **lowercase							)


	def     _a	(self       ,      *lowercase       ,      **lowercase							):
				return self.tokenizer.decode(*lowercase       ,      **lowercase							)


	@property
	def     _a	(self							):
				A_	:						int	=     self.tokenizer.model_input_names
				A_	:						Any	=     self.image_processor.model_input_names
				return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names							)							)