





from typing import List

import numpy as np





def  __magic_name__  (				lowercase				)				-> int:

							"""simple docstring"""



							lowercase_	:   List[Any]  				=     {key: len(SCREAMING_SNAKE_CASE__				) for key, value in gen_kwargs.items() if isinstance(SCREAMING_SNAKE_CASE__				,       SCREAMING_SNAKE_CASE__				)}
							if len(set(lists_lengths.values()				)				) > 1:
														raise RuntimeError(
														    (
														        """Sharding is ambiguous for this dataset: """
														        + """we found several data sources lists of different lengths, and we don\'t know over which list we should parallelize:\n"""
														        + """\n""".join(f"""\t- key {key} has length {length}""" for key, length in lists_lengths.items()				)
														        + """\nTo fix this, check the \'gen_kwargs\' and make sure to use lists only for data sources, """
														        + """and use tuples otherwise. In the end there should only be one single list, or several lists with the same length."""
														    )				)
							lowercase_	:   List[Any]  				=     max(lists_lengths.values()				,       default=0				)
							return max(1				,       SCREAMING_SNAKE_CASE__				)





def  __magic_name__  (				lowercase				,       lowercase				)				-> List[range]:

							"""simple docstring"""



							lowercase_	:   Dict  				=     []
							for group_idx in range(SCREAMING_SNAKE_CASE__				):
														lowercase_	:   List[Any]  				=     num_shards // max_num_jobs + (group_idx < (num_shards % max_num_jobs))
														if num_shards_to_add == 0:
																					break
														lowercase_	:   Optional[Any]  				=     shards_indices_per_group[-1].stop if shards_indices_per_group else 0
														lowercase_	:   Any  				=     range(SCREAMING_SNAKE_CASE__				,       start + num_shards_to_add				)
														shards_indices_per_group.append(SCREAMING_SNAKE_CASE__				)
							return shards_indices_per_group





def  __magic_name__  (				lowercase				,       lowercase				)				-> List[dict]:

							"""simple docstring"""



							lowercase_	:   Dict  				=     _number_of_shards_in_gen_kwargs(SCREAMING_SNAKE_CASE__				)
							if num_shards == 1:
														return [dict(SCREAMING_SNAKE_CASE__				)]
							else:
														lowercase_	:   Optional[Any]  				=     _distribute_shards(num_shards=SCREAMING_SNAKE_CASE__				,       max_num_jobs=SCREAMING_SNAKE_CASE__				)
														return [
														    {
														        key: [value[shard_idx] for shard_idx in shard_indices_per_group[group_idx]]
														        if isinstance(SCREAMING_SNAKE_CASE__				,       SCREAMING_SNAKE_CASE__				)
														        else value
														        for key, value in gen_kwargs.items()
														    }
														    for group_idx in range(len(SCREAMING_SNAKE_CASE__				)				)
														]





def  __magic_name__  (				lowercase				)				-> dict:

							"""simple docstring"""



							return {
							    key: [value for gen_kwargs in gen_kwargs_list for value in gen_kwargs[key]]
							    if isinstance(gen_kwargs_list[0][key]				,       SCREAMING_SNAKE_CASE__				)
							    else gen_kwargs_list[0][key]
							    for key in gen_kwargs_list[0]
							}





def  __magic_name__  (				lowercase				,       lowercase				)				-> dict:

							"""simple docstring"""



							lowercase_	:   Optional[int]  				=     {len(SCREAMING_SNAKE_CASE__				) for value in gen_kwargs.values() if isinstance(SCREAMING_SNAKE_CASE__				,       SCREAMING_SNAKE_CASE__				)}
							lowercase_	:   Tuple  				=     {}
							for size in list_sizes:
														lowercase_	:   List[Any]  				=     list(range(SCREAMING_SNAKE_CASE__				)				)
														rng.shuffle(indices_per_size[size]				)
							# Now let's copy the gen_kwargs and shuffle the lists based on their sizes
							lowercase_	:   Any  				=     dict(SCREAMING_SNAKE_CASE__				)
							for key, value in shuffled_kwargs.items():
														if isinstance(SCREAMING_SNAKE_CASE__				,       SCREAMING_SNAKE_CASE__				):
																					lowercase_	:   List[Any]  				=     [value[i] for i in indices_per_size[len(SCREAMING_SNAKE_CASE__				)]]
							return shuffled_kwargs

'''simple docstring'''
import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import DetrConfig, DetrForObjectDetection, DetrForSegmentation, DetrImageProcessor, ResNetConfig
from transformers.utils import logging


logging.set_verbosity_info()
lowercase__						       =      logging.get_logger(__name__)




def    _UpperCamelCase						(       SCREAMING_SNAKE_CASE__			)  ->							Tuple:


		'''simple docstring'''


		if "resnet-50" in model_name:
				snake_case  :       int     			=						ResNetConfig.from_pretrained('''microsoft/resnet-50'''			)
		elif "resnet-101" in model_name:
				snake_case  :       Any     			=						ResNetConfig.from_pretrained('''microsoft/resnet-101'''			)
		else:
				raise ValueError('''Model name should include either resnet50 or resnet101'''			)

		snake_case  :       Optional[Any]     			=						DetrConfig(use_timm_backbone=SCREAMING_SNAKE_CASE__ ,       backbone_config=SCREAMING_SNAKE_CASE__			)

		# set label attributes
		snake_case  :       Tuple     			=						'''panoptic''' in model_name
		if is_panoptic:
				snake_case  :       Tuple     			=						250
		else:
				snake_case  :       Any     			=						91
				snake_case  :       str     			=						'''huggingface/label-files'''
				snake_case  :       Optional[Any]     			=						'''coco-detection-id2label.json'''
				snake_case  :       List[str]     			=						json.load(open(hf_hub_download(SCREAMING_SNAKE_CASE__ ,       SCREAMING_SNAKE_CASE__ ,       repo_type='''dataset'''			) ,       '''r'''			)			)
				snake_case  :       Optional[Any]     			=						{int(SCREAMING_SNAKE_CASE__			): v for k, v in idalabel.items()}
				snake_case  :       str     			=						idalabel
				snake_case  :       List[Any]     			=						{v: k for k, v in idalabel.items()}

		return config, is_panoptic




def    _UpperCamelCase						(       SCREAMING_SNAKE_CASE__			)  ->							Optional[Any]:


		'''simple docstring'''


		snake_case  :       str     			=						[]

		# stem
		# fmt: off
		rename_keys.append(('''backbone.0.body.conv1.weight''', '''backbone.conv_encoder.model.embedder.embedder.convolution.weight''')			)
		rename_keys.append(('''backbone.0.body.bn1.weight''', '''backbone.conv_encoder.model.embedder.embedder.normalization.weight''')			)
		rename_keys.append(('''backbone.0.body.bn1.bias''', '''backbone.conv_encoder.model.embedder.embedder.normalization.bias''')			)
		rename_keys.append(('''backbone.0.body.bn1.running_mean''', '''backbone.conv_encoder.model.embedder.embedder.normalization.running_mean''')			)
		rename_keys.append(('''backbone.0.body.bn1.running_var''', '''backbone.conv_encoder.model.embedder.embedder.normalization.running_var''')			)
		# stages
		for stage_idx in range(len(config.backbone_config.depths			)			):
				for layer_idx in range(config.backbone_config.depths[stage_idx]			):
						# shortcut
						if layer_idx == 0:
								rename_keys.append(
								    (
								        F'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.0.weight',
								        F'backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.convolution.weight',
								    )			)
								rename_keys.append(
								    (
								        F'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.weight',
								        F'backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.weight',
								    )			)
								rename_keys.append(
								    (
								        F'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.bias',
								        F'backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.bias',
								    )			)
								rename_keys.append(
								    (
								        F'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_mean',
								        F'backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_mean',
								    )			)
								rename_keys.append(
								    (
								        F'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_var',
								        F'backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_var',
								    )			)
						# 3 convs
						for i in range(3			):
								rename_keys.append(
								    (
								        F'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.conv{i+1}.weight',
								        F'backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.convolution.weight',
								    )			)
								rename_keys.append(
								    (
								        F'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.weight',
								        F'backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.weight',
								    )			)
								rename_keys.append(
								    (
								        F'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.bias',
								        F'backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.bias',
								    )			)
								rename_keys.append(
								    (
								        F'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_mean',
								        F'backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_mean',
								    )			)
								rename_keys.append(
								    (
								        F'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_var',
								        F'backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_var',
								    )			)
    # fmt: on

		for i in range(config.encoder_layers			):
				# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
				rename_keys.append(
				    (
				        F'transformer.encoder.layers.{i}.self_attn.out_proj.weight',
				        F'encoder.layers.{i}.self_attn.out_proj.weight',
				    )			)
				rename_keys.append(
				    (F'transformer.encoder.layers.{i}.self_attn.out_proj.bias', F'encoder.layers.{i}.self_attn.out_proj.bias')			)
				rename_keys.append((F'transformer.encoder.layers.{i}.linear1.weight', F'encoder.layers.{i}.fc1.weight')			)
				rename_keys.append((F'transformer.encoder.layers.{i}.linear1.bias', F'encoder.layers.{i}.fc1.bias')			)
				rename_keys.append((F'transformer.encoder.layers.{i}.linear2.weight', F'encoder.layers.{i}.fc2.weight')			)
				rename_keys.append((F'transformer.encoder.layers.{i}.linear2.bias', F'encoder.layers.{i}.fc2.bias')			)
				rename_keys.append(
				    (F'transformer.encoder.layers.{i}.norm1.weight', F'encoder.layers.{i}.self_attn_layer_norm.weight')			)
				rename_keys.append(
				    (F'transformer.encoder.layers.{i}.norm1.bias', F'encoder.layers.{i}.self_attn_layer_norm.bias')			)
				rename_keys.append(
				    (F'transformer.encoder.layers.{i}.norm2.weight', F'encoder.layers.{i}.final_layer_norm.weight')			)
				rename_keys.append((F'transformer.encoder.layers.{i}.norm2.bias', F'encoder.layers.{i}.final_layer_norm.bias')			)
				# decoder layers: 2 times output projection, 2 feedforward neural networks and 3 layernorms
				rename_keys.append(
				    (
				        F'transformer.decoder.layers.{i}.self_attn.out_proj.weight',
				        F'decoder.layers.{i}.self_attn.out_proj.weight',
				    )			)
				rename_keys.append(
				    (F'transformer.decoder.layers.{i}.self_attn.out_proj.bias', F'decoder.layers.{i}.self_attn.out_proj.bias')			)
				rename_keys.append(
				    (
				        F'transformer.decoder.layers.{i}.multihead_attn.out_proj.weight',
				        F'decoder.layers.{i}.encoder_attn.out_proj.weight',
				    )			)
				rename_keys.append(
				    (
				        F'transformer.decoder.layers.{i}.multihead_attn.out_proj.bias',
				        F'decoder.layers.{i}.encoder_attn.out_proj.bias',
				    )			)
				rename_keys.append((F'transformer.decoder.layers.{i}.linear1.weight', F'decoder.layers.{i}.fc1.weight')			)
				rename_keys.append((F'transformer.decoder.layers.{i}.linear1.bias', F'decoder.layers.{i}.fc1.bias')			)
				rename_keys.append((F'transformer.decoder.layers.{i}.linear2.weight', F'decoder.layers.{i}.fc2.weight')			)
				rename_keys.append((F'transformer.decoder.layers.{i}.linear2.bias', F'decoder.layers.{i}.fc2.bias')			)
				rename_keys.append(
				    (F'transformer.decoder.layers.{i}.norm1.weight', F'decoder.layers.{i}.self_attn_layer_norm.weight')			)
				rename_keys.append(
				    (F'transformer.decoder.layers.{i}.norm1.bias', F'decoder.layers.{i}.self_attn_layer_norm.bias')			)
				rename_keys.append(
				    (F'transformer.decoder.layers.{i}.norm2.weight', F'decoder.layers.{i}.encoder_attn_layer_norm.weight')			)
				rename_keys.append(
				    (F'transformer.decoder.layers.{i}.norm2.bias', F'decoder.layers.{i}.encoder_attn_layer_norm.bias')			)
				rename_keys.append(
				    (F'transformer.decoder.layers.{i}.norm3.weight', F'decoder.layers.{i}.final_layer_norm.weight')			)
				rename_keys.append((F'transformer.decoder.layers.{i}.norm3.bias', F'decoder.layers.{i}.final_layer_norm.bias')			)

		# convolutional projection + query embeddings + layernorm of decoder + class and bounding box heads
		rename_keys.extend(
		    [
		        ('''input_proj.weight''', '''input_projection.weight'''),
		        ('''input_proj.bias''', '''input_projection.bias'''),
		        ('''query_embed.weight''', '''query_position_embeddings.weight'''),
		        ('''transformer.decoder.norm.weight''', '''decoder.layernorm.weight'''),
		        ('''transformer.decoder.norm.bias''', '''decoder.layernorm.bias'''),
		        ('''class_embed.weight''', '''class_labels_classifier.weight'''),
		        ('''class_embed.bias''', '''class_labels_classifier.bias'''),
		        ('''bbox_embed.layers.0.weight''', '''bbox_predictor.layers.0.weight'''),
		        ('''bbox_embed.layers.0.bias''', '''bbox_predictor.layers.0.bias'''),
		        ('''bbox_embed.layers.1.weight''', '''bbox_predictor.layers.1.weight'''),
		        ('''bbox_embed.layers.1.bias''', '''bbox_predictor.layers.1.bias'''),
		        ('''bbox_embed.layers.2.weight''', '''bbox_predictor.layers.2.weight'''),
		        ('''bbox_embed.layers.2.bias''', '''bbox_predictor.layers.2.bias'''),
		    ]			)

		return rename_keys




def    _UpperCamelCase						(       SCREAMING_SNAKE_CASE__ ,       SCREAMING_SNAKE_CASE__ ,       SCREAMING_SNAKE_CASE__			)  ->							List[str]:


		'''simple docstring'''


		snake_case  :       List[str]     			=						state_dict.pop(SCREAMING_SNAKE_CASE__			)
		snake_case  :       List[Any]     			=						val




def    _UpperCamelCase						(       SCREAMING_SNAKE_CASE__ ,       SCREAMING_SNAKE_CASE__=False			)  ->							List[Any]:


		'''simple docstring'''


		snake_case  :       Union[str, Any]     			=						''''''
		if is_panoptic:
				snake_case  :       Optional[Any]     			=						'''detr.'''

		# first: transformer encoder
		for i in range(6			):
				# read in weights + bias of input projection layer (in PyTorch's MultiHeadAttention, this is a single matrix + bias)
				snake_case  :       Dict     			=						state_dict.pop(F'{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_weight'			)
				snake_case  :       Optional[Any]     			=						state_dict.pop(F'{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_bias'			)
				# next, add query, keys and values (in that order) to the state dict
				snake_case  :       Union[str, Any]     			=						in_proj_weight[:256, :]
				snake_case  :       Any     			=						in_proj_bias[:256]
				snake_case  :       Dict     			=						in_proj_weight[256:512, :]
				snake_case  :       Tuple     			=						in_proj_bias[256:512]
				snake_case  :       Optional[int]     			=						in_proj_weight[-256:, :]
				snake_case  :       Optional[int]     			=						in_proj_bias[-256:]
		# next: transformer decoder (which is a bit more complex because it also includes cross-attention)
		for i in range(6			):
				# read in weights + bias of input projection layer of self-attention
				snake_case  :       Union[str, Any]     			=						state_dict.pop(F'{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_weight'			)
				snake_case  :       List[str]     			=						state_dict.pop(F'{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_bias'			)
				# next, add query, keys and values (in that order) to the state dict
				snake_case  :       Union[str, Any]     			=						in_proj_weight[:256, :]
				snake_case  :       str     			=						in_proj_bias[:256]
				snake_case  :       Optional[int]     			=						in_proj_weight[256:512, :]
				snake_case  :       Optional[int]     			=						in_proj_bias[256:512]
				snake_case  :       Optional[Any]     			=						in_proj_weight[-256:, :]
				snake_case  :       Tuple     			=						in_proj_bias[-256:]
				# read in weights + bias of input projection layer of cross-attention
				snake_case  :       Union[str, Any]     			=						state_dict.pop(
				    F'{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_weight'			)
				snake_case  :       str     			=						state_dict.pop(F'{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_bias'			)
				# next, add query, keys and values (in that order) of cross-attention to the state dict
				snake_case  :       Optional[Any]     			=						in_proj_weight_cross_attn[:256, :]
				snake_case  :       List[Any]     			=						in_proj_bias_cross_attn[:256]
				snake_case  :       Union[str, Any]     			=						in_proj_weight_cross_attn[256:512, :]
				snake_case  :       Any     			=						in_proj_bias_cross_attn[256:512]
				snake_case  :       List[str]     			=						in_proj_weight_cross_attn[-256:, :]
				snake_case  :       Tuple     			=						in_proj_bias_cross_attn[-256:]




def    _UpperCamelCase						(       )  ->							Dict:


		'''simple docstring'''


		snake_case  :       Optional[Any]     			=						'''http://images.cocodataset.org/val2017/000000039769.jpg'''
		snake_case  :       Any     			=						Image.open(requests.get(SCREAMING_SNAKE_CASE__ ,       stream=SCREAMING_SNAKE_CASE__			).raw			)

		return im




@torch.no_grad()
def    _UpperCamelCase						(       SCREAMING_SNAKE_CASE__ ,       SCREAMING_SNAKE_CASE__=None ,       SCREAMING_SNAKE_CASE__=False			)  ->							Dict:


		'''simple docstring'''


		snake_case			,snake_case  :       Tuple     			=						get_detr_config(SCREAMING_SNAKE_CASE__			)

		# load original model from torch hub
		snake_case  :       Union[str, Any]     			=						{
		    '''detr-resnet-50''': '''detr_resnet50''',
		    '''detr-resnet-101''': '''detr_resnet101''',
		}
		logger.info(F'Converting model {model_name}...'			)
		snake_case  :       Union[str, Any]     			=						torch.hub.load('''facebookresearch/detr''' ,       model_name_to_original_name[model_name] ,       pretrained=SCREAMING_SNAKE_CASE__			).eval()
		snake_case  :       Optional[int]     			=						detr.state_dict()
		# rename keys
		for src, dest in create_rename_keys(SCREAMING_SNAKE_CASE__			):
				if is_panoptic:
						snake_case  :       Union[str, Any]     			=						'''detr.''' + src
				rename_key(SCREAMING_SNAKE_CASE__ ,       SCREAMING_SNAKE_CASE__ ,       SCREAMING_SNAKE_CASE__			)
		# query, key and value matrices need special treatment
		read_in_q_k_v(SCREAMING_SNAKE_CASE__ ,       is_panoptic=SCREAMING_SNAKE_CASE__			)
		# important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
		snake_case  :       List[str]     			=						'''detr.model.''' if is_panoptic else '''model.'''
		for key in state_dict.copy().keys():
				if is_panoptic:
						if (
						    key.startswith('''detr'''			)
						    and not key.startswith('''class_labels_classifier'''			)
						    and not key.startswith('''bbox_predictor'''			)
						):
								snake_case  :       Optional[Any]     			=						state_dict.pop(SCREAMING_SNAKE_CASE__			)
								snake_case  :       Optional[int]     			=						val
						elif "class_labels_classifier" in key or "bbox_predictor" in key:
								snake_case  :       Dict     			=						state_dict.pop(SCREAMING_SNAKE_CASE__			)
								snake_case  :       List[Any]     			=						val
						elif key.startswith('''bbox_attention'''			) or key.startswith('''mask_head'''			):
								continue
						else:
								snake_case  :       int     			=						state_dict.pop(SCREAMING_SNAKE_CASE__			)
								snake_case  :       Optional[int]     			=						val
				else:
						if not key.startswith('''class_labels_classifier'''			) and not key.startswith('''bbox_predictor'''			):
								snake_case  :       Dict     			=						state_dict.pop(SCREAMING_SNAKE_CASE__			)
								snake_case  :       Any     			=						val

    # finally, create HuggingFace model and load state dict
		snake_case  :       Optional[Any]     			=						DetrForSegmentation(SCREAMING_SNAKE_CASE__			) if is_panoptic else DetrForObjectDetection(SCREAMING_SNAKE_CASE__			)
		model.load_state_dict(SCREAMING_SNAKE_CASE__			)
		model.eval()

		# verify our conversion on an image
		snake_case  :       List[str]     			=						'''coco_panoptic''' if is_panoptic else '''coco_detection'''
		snake_case  :       Optional[int]     			=						DetrImageProcessor(format=SCREAMING_SNAKE_CASE__			)

		snake_case  :       int     			=						processor(images=prepare_img() ,       return_tensors='''pt'''			)
		snake_case  :       Optional[int]     			=						encoding['''pixel_values''']

		snake_case  :       str     			=						detr(SCREAMING_SNAKE_CASE__			)
		snake_case  :       Optional[int]     			=						model(SCREAMING_SNAKE_CASE__			)

		assert torch.allclose(outputs.logits ,       original_outputs['''pred_logits'''] ,       atol=1E-3			)
		assert torch.allclose(outputs.pred_boxes ,       original_outputs['''pred_boxes'''] ,       atol=1E-3			)
		if is_panoptic:
				assert torch.allclose(outputs.pred_masks ,       original_outputs['''pred_masks'''] ,       atol=1E-4			)
		print('''Looks ok!'''			)

		if pytorch_dump_folder_path is not None:
				# Save model and image processor
				logger.info(F'Saving PyTorch model and image processor to {pytorch_dump_folder_path}...'			)
				Path(SCREAMING_SNAKE_CASE__			).mkdir(exist_ok=SCREAMING_SNAKE_CASE__			)
				model.save_pretrained(SCREAMING_SNAKE_CASE__			)
				processor.save_pretrained(SCREAMING_SNAKE_CASE__			)

		if push_to_hub:
				# Upload model and image processor to the hub
				logger.info('''Uploading PyTorch model and image processor to the hub...'''			)
				model.push_to_hub(F'nielsr/{model_name}'			)
				processor.push_to_hub(F'nielsr/{model_name}'			)


if __name__ == "__main__":
						lowercase__						       =      argparse.ArgumentParser()

						parser.add_argument(
						    "--model_name",
						    default="detr-resnet-50",
						    type=str,
						    choices=["detr-resnet-50", "detr-resnet-101"],
						    help="Name of the DETR 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 to push the model to the hub or not.")
						lowercase__						       =      parser.parse_args()
						convert_detr_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)


