




'''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()
_snake_case : Union[str, Any]  				=						logging.get_logger(__name__)
def 						snake_case_       (UpperCamelCase			:    Optional[int] ):





							'''simple docstring'''


							_a      	=							SwinConfig(
							    embed_dim=192					,		depths=(2, 2, 18, 2)					,		num_heads=(6, 12, 24, 48)					,		window_size=12					,		out_features=['''stage2''', '''stage3''', '''stage4''']					,		)

							_a      	=							DetaConfig(
							    backbone_config=UpperCamelCase					,		num_queries=900					,		encoder_ffn_dim=2048					,		decoder_ffn_dim=2048					,		num_feature_levels=5					,		assign_first_stage=UpperCamelCase					,		with_box_refine=UpperCamelCase					,		two_stage=UpperCamelCase					,		)

							# set labels
							_a      	=							'''huggingface/label-files'''
							if "o365" in model_name:
														_a      	=							366
														_a      	=							'''object365-id2label.json'''
							else:
														_a      	=							91
														_a      	=							'''coco-detection-id2label.json'''

							_a      	=							num_labels
							_a      	=							json.load(open(cached_download(hf_hub_url(UpperCamelCase					,		UpperCamelCase					,		repo_type='''dataset''' ) )					,		'''r''' ) )
							_a      	=							{int(UpperCamelCase ): v for k, v in idalabel.items()}
							_a      	=							idalabel
							_a      	=							{v: k for k, v in idalabel.items()}

							return config
def 						snake_case_       (UpperCamelCase			:    Optional[Any] ):





							'''simple docstring'''


							_a      	=							[]

							# 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 						snake_case_       (UpperCamelCase			:    Optional[int]					,		UpperCamelCase			:    Optional[Any]					,		UpperCamelCase			:    Optional[Any] ):





							'''simple docstring'''


							_a      	=							dct.pop(UpperCamelCase )
							_a      	=							val
def 						snake_case_       (UpperCamelCase			:    Optional[Any]					,		UpperCamelCase			:    Tuple ):





							'''simple docstring'''


							_a      	=							[int(backbone_config.embed_dim * 2**i ) for i in range(len(backbone_config.depths ) )]
							for i in range(len(backbone_config.depths ) ):
														_a      	=							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      	=							state_dict.pop(f'backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.weight' )
																					_a      	=							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      	=							in_proj_weight[:dim, :]
																					_a      	=							in_proj_bias[: dim]
																					_a      	=							in_proj_weight[
																					    dim : dim * 2, :
																					]
																					_a      	=							in_proj_bias[
																					    dim : dim * 2
																					]
																					_a      	=							in_proj_weight[
																					    -dim :, :
																					]
																					_a      	=							in_proj_bias[-dim :]
																					# fmt: on
def 						snake_case_       (UpperCamelCase			:    Any					,		UpperCamelCase			:    Dict ):





							'''simple docstring'''


							_a      	=							config.d_model
							for i in range(config.decoder_layers ):
														# read in weights + bias of input projection layer of self-attention
														_a      	=							state_dict.pop(f'transformer.decoder.layers.{i}.self_attn.in_proj_weight' )
														_a      	=							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      	=							in_proj_weight[:hidden_size, :]
														_a      	=							in_proj_bias[:hidden_size]
														_a      	=							in_proj_weight[
														    hidden_size : hidden_size * 2, :
														]
														_a      	=							in_proj_bias[hidden_size : hidden_size * 2]
														_a      	=							in_proj_weight[-hidden_size:, :]
														_a      	=							in_proj_bias[-hidden_size:]
def 						snake_case_       ():





							'''simple docstring'''


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

							return im
@torch.no_grad()
def 						snake_case_       (UpperCamelCase			:    int					,		UpperCamelCase			:    Dict					,		UpperCamelCase			:    Union[str, Any] ):





							'''simple docstring'''


							_a      	=							get_deta_config(UpperCamelCase )

							# load original state dict
							if model_name == "deta-swin-large":
														_a      	=							hf_hub_download(repo_id='''nielsr/deta-checkpoints'''					,		filename='''adet_swin_ft.pth''' )
							elif model_name == "deta-swin-large-o365":
														_a      	=							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      	=							torch.load(UpperCamelCase					,		map_location='''cpu''' )['''model''']

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

							# rename keys
							_a      	=							create_rename_keys(UpperCamelCase )
							for src, dest in rename_keys:
														rename_key(UpperCamelCase					,		UpperCamelCase					,		UpperCamelCase )
							read_in_swin_q_k_v(UpperCamelCase					,		config.backbone_config )
							read_in_decoder_q_k_v(UpperCamelCase					,		UpperCamelCase )

							# 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      	=							state_dict.pop(UpperCamelCase )
																					_a      	=							val
														if "input_proj" in key:
																					_a      	=							state_dict.pop(UpperCamelCase )
																					_a      	=							val
														if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
																					_a      	=							state_dict.pop(UpperCamelCase )
																					_a      	=							val

    # finally, create HuggingFace model and load state dict
							_a      	=							DetaForObjectDetection(UpperCamelCase )
							model.load_state_dict(UpperCamelCase )
							model.eval()

							_a      	=							'''cuda''' if torch.cuda.is_available() else '''cpu'''
							model.to(UpperCamelCase )

							# load image processor
							_a      	=							DetaImageProcessor(format='''coco_detection''' )

							# verify our conversion on image
							_a      	=							prepare_img()
							_a      	=							processor(images=UpperCamelCase					,		return_tensors='''pt''' )
							_a      	=							encoding['''pixel_values''']
							_a      	=							model(pixel_values.to(UpperCamelCase ) )

							# verify logits
							print('''Logits:'''					,		outputs.logits[0, :3, :3] )
							print('''Boxes:'''					,		outputs.pred_boxes[0, :3, :3] )
							if model_name == "deta-swin-large":
														_a      	=							torch.tensor(
														    [[-7.6308, -2.8485, -5.3737], [-7.2037, -4.5505, -4.8027], [-7.2943, -4.2611, -4.6617]] )
														_a      	=							torch.tensor([[0.4987, 0.4969, 0.9999], [0.2549, 0.5498, 0.4805], [0.5498, 0.2757, 0.0569]] )
							elif model_name == "deta-swin-large-o365":
														_a      	=							torch.tensor(
														    [[-8.0122, -3.5720, -4.9717], [-8.1547, -3.6886, -4.6389], [-7.6610, -3.6194, -5.0134]] )
														_a      	=							torch.tensor([[0.2523, 0.5549, 0.4881], [0.7715, 0.4149, 0.4601], [0.5503, 0.2753, 0.0575]] )
							assert torch.allclose(outputs.logits[0, :3, :3]					,		expected_logits.to(UpperCamelCase )					,		atol=1e-4 )
							assert torch.allclose(outputs.pred_boxes[0, :3, :3]					,		expected_boxes.to(UpperCamelCase )					,		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(UpperCamelCase ).mkdir(exist_ok=UpperCamelCase )
														model.save_pretrained(UpperCamelCase )
														processor.save_pretrained(UpperCamelCase )

							# 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__":
				_snake_case : str  				=						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.'
				)
				_snake_case : Optional[Any]  				=						parser.parse_args()
				convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)







'''simple docstring'''


import unittest

from transformers import is_flax_available
from transformers.testing_utils import require_flax, require_sentencepiece, require_tokenizers, require_torch, slow


if is_flax_available():
				import optax
				from flax.training.common_utils import onehot

				from transformers import AutoTokenizer, FlaxMTaForConditionalGeneration
				from transformers.models.ta.modeling_flax_ta import shift_tokens_right

@require_torch
@require_sentencepiece
@require_tokenizers
@require_flax
class      A       (						unittest.TestCase       ):







							@slow
							def   __lowerCAmelCase     (    self			:    List[Any]   )     ->				Union[str, Any]:


														"""simple docstring"""


														_a      	=							FlaxMTaForConditionalGeneration.from_pretrained('''google/mt5-small'''   )
														_a      	=							AutoTokenizer.from_pretrained('''google/mt5-small'''   )

														_a      	=							tokenizer('''Hello there'''				,     return_tensors='''np'''   ).input_ids
														_a      	=							tokenizer('''Hi I am'''				,     return_tensors='''np'''   ).input_ids

														_a      	=							shift_tokens_right(lowerCAmelCase_				,     model.config.pad_token_id				,     model.config.decoder_start_token_id   )

														_a      	=							model(lowerCAmelCase_				,     decoder_input_ids=lowerCAmelCase_   ).logits
														_a      	=							optax.softmax_cross_entropy(lowerCAmelCase_				,     onehot(lowerCAmelCase_				,     logits.shape[-1]   )   ).mean()

														_a      	=							-(labels.shape[-1] * loss.item())

														_a      	=							-8_4.9_1_2_7
														self.assertTrue(abs(mtf_score - EXPECTED_SCORE   ) < 1e-4   )

