




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()
__A								=       logging.get_logger(__name__)







def      lowerCamelCase_						(			UpperCamelCase__							: Union[str, Any] )	->			int:





				"""simple docstring"""


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

				__lowerCamelCase									=       DetrConfig(use_timm_backbone=UpperCamelCase__					,	backbone_config=UpperCamelCase__ )

				# set label attributes
				__lowerCamelCase									=       'panoptic' in model_name
				if is_panoptic:
								__lowerCamelCase									=       250
				else:
								__lowerCamelCase									=       91
								__lowerCamelCase									=       'huggingface/label-files'
								__lowerCamelCase									=       'coco-detection-id2label.json'
								__lowerCamelCase									=       json.load(open(hf_hub_download(UpperCamelCase__					,	UpperCamelCase__					,	repo_type='dataset' )					,	'r' ) )
								__lowerCamelCase									=       {int(UpperCamelCase__ ): v for k, v in idalabel.items()}
								__lowerCamelCase									=       idalabel
								__lowerCamelCase									=       {v: k for k, v in idalabel.items()}

				return config, is_panoptic







def      lowerCamelCase_						(			UpperCamelCase__							: Dict )	->			List[Any]:





				"""simple docstring"""


				__lowerCamelCase									=       []

				# 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      lowerCamelCase_						(			UpperCamelCase__							: Optional[int]					,	UpperCamelCase__							: int					,	UpperCamelCase__							: str )	->			Optional[Any]:





				"""simple docstring"""


				__lowerCamelCase									=       state_dict.pop(UpperCamelCase__ )
				__lowerCamelCase									=       val







def      lowerCamelCase_						(			UpperCamelCase__							: List[Any]					,	UpperCamelCase__							: int=False )	->			List[Any]:





				"""simple docstring"""


				__lowerCamelCase									=       ''
				if is_panoptic:
								__lowerCamelCase									=       '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)
								__lowerCamelCase									=       state_dict.pop(F"""{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_weight""" )
								__lowerCamelCase									=       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
								__lowerCamelCase									=       in_proj_weight[:256, :]
								__lowerCamelCase									=       in_proj_bias[:256]
								__lowerCamelCase									=       in_proj_weight[256:512, :]
								__lowerCamelCase									=       in_proj_bias[256:512]
								__lowerCamelCase									=       in_proj_weight[-256:, :]
								__lowerCamelCase									=       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
								__lowerCamelCase									=       state_dict.pop(F"""{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_weight""" )
								__lowerCamelCase									=       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
								__lowerCamelCase									=       in_proj_weight[:256, :]
								__lowerCamelCase									=       in_proj_bias[:256]
								__lowerCamelCase									=       in_proj_weight[256:512, :]
								__lowerCamelCase									=       in_proj_bias[256:512]
								__lowerCamelCase									=       in_proj_weight[-256:, :]
								__lowerCamelCase									=       in_proj_bias[-256:]
								# read in weights + bias of input projection layer of cross-attention
								__lowerCamelCase									=       state_dict.pop(
								    F"""{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_weight""" )
								__lowerCamelCase									=       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
								__lowerCamelCase									=       in_proj_weight_cross_attn[:256, :]
								__lowerCamelCase									=       in_proj_bias_cross_attn[:256]
								__lowerCamelCase									=       in_proj_weight_cross_attn[256:512, :]
								__lowerCamelCase									=       in_proj_bias_cross_attn[256:512]
								__lowerCamelCase									=       in_proj_weight_cross_attn[-256:, :]
								__lowerCamelCase									=       in_proj_bias_cross_attn[-256:]







def      lowerCamelCase_						(			)	->			str:





				"""simple docstring"""


				__lowerCamelCase									=       'http://images.cocodataset.org/val2017/000000039769.jpg'
				__lowerCamelCase									=       Image.open(requests.get(UpperCamelCase__					,	stream=UpperCamelCase__ ).raw )

				return im







@torch.no_grad()
def      lowerCamelCase_						(			UpperCamelCase__							: int					,	UpperCamelCase__							: Optional[Any]=None					,	UpperCamelCase__							: Tuple=False )	->			Optional[int]:





				"""simple docstring"""


				__lowerCamelCase			,		__lowerCamelCase									=       get_detr_config(UpperCamelCase__ )

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

    # finally, create HuggingFace model and load state dict
				__lowerCamelCase									=       DetrForSegmentation(UpperCamelCase__ ) if is_panoptic else DetrForObjectDetection(UpperCamelCase__ )
				model.load_state_dict(UpperCamelCase__ )
				model.eval()

				# verify our conversion on an image
				__lowerCamelCase									=       'coco_panoptic' if is_panoptic else 'coco_detection'
				__lowerCamelCase									=       DetrImageProcessor(format=UpperCamelCase__ )

				__lowerCamelCase									=       processor(images=prepare_img()					,	return_tensors='pt' )
				__lowerCamelCase									=       encoding['pixel_values']

				__lowerCamelCase									=       detr(UpperCamelCase__ )
				__lowerCamelCase									=       model(UpperCamelCase__ )

				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(UpperCamelCase__ ).mkdir(exist_ok=UpperCamelCase__ )
								model.save_pretrained(UpperCamelCase__ )
								processor.save_pretrained(UpperCamelCase__ )

				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__":
					__A								=       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.")
					__A								=       parser.parse_args()
					convert_detr_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)








from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


__A								=       logging.get_logger(__name__)

__A								=       {
    "facebook/xlm-roberta-xl": "https://huggingface.co/facebook/xlm-roberta-xl/resolve/main/config.json",
    "facebook/xlm-roberta-xxl": "https://huggingface.co/facebook/xlm-roberta-xxl/resolve/main/config.json",
    # See all XLM-RoBERTa-XL models at https://huggingface.co/models?filter=xlm-roberta-xl
}







class        __lowerCAmelCase					(			__magic_name__					):

			"""simple docstring"""







			snake_case_  						=			'''xlm-roberta-xl'''


			def __init__( self     ,		lowerCamelCase__=250_880     ,		lowerCamelCase__=2_560     ,		lowerCamelCase__=36     ,		lowerCamelCase__=32     ,		lowerCamelCase__=10_240     ,		lowerCamelCase__="gelu"     ,		lowerCamelCase__=0.1     ,		lowerCamelCase__=0.1     ,		lowerCamelCase__=514     ,		lowerCamelCase__=1     ,		lowerCamelCase__=0.02     ,		lowerCamelCase__=1e-05     ,		lowerCamelCase__=1     ,		lowerCamelCase__=0     ,		lowerCamelCase__=2     ,		lowerCamelCase__="absolute"     ,		lowerCamelCase__=True     ,		lowerCamelCase__=None     ,		**lowerCamelCase__     ,		)       -> str:



							'''simple docstring'''
							super().__init__(pad_token_id=lowerCamelCase__     ,		bos_token_id=lowerCamelCase__     ,		eos_token_id=lowerCamelCase__     ,		**lowerCamelCase__				)
							__lowerCamelCase									=       vocab_size
							__lowerCamelCase									=       hidden_size
							__lowerCamelCase									=       num_hidden_layers
							__lowerCamelCase									=       num_attention_heads
							__lowerCamelCase									=       hidden_act
							__lowerCamelCase									=       intermediate_size
							__lowerCamelCase									=       hidden_dropout_prob
							__lowerCamelCase									=       attention_probs_dropout_prob
							__lowerCamelCase									=       max_position_embeddings
							__lowerCamelCase									=       type_vocab_size
							__lowerCamelCase									=       initializer_range
							__lowerCamelCase									=       layer_norm_eps
							__lowerCamelCase									=       position_embedding_type
							__lowerCamelCase									=       use_cache
							__lowerCamelCase									=       classifier_dropout







class        __lowerCAmelCase					(			__magic_name__					):

			"""simple docstring"""







			@property
			def  lowercase_       ( self				)       -> Mapping[str, Mapping[int, str]]:



							'''simple docstring'''
							if self.task == "multiple-choice":
											__lowerCamelCase									=       {0: 'batch', 1: 'choice', 2: 'sequence'}
							else:
											__lowerCamelCase									=       {0: 'batch', 1: 'sequence'}
							return OrderedDict(
							    [
							        ('input_ids', dynamic_axis),
							        ('attention_mask', dynamic_axis),
							    ]				)


