






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
from transformers.utils import logging


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

def     lowerCAmelCase__  (  ):



  '''simple docstring'''
  _a						: str    =			DetaConfig(
      num_queries=9_0_0  ,     encoder_ffn_dim=2_0_4_8  ,     decoder_ffn_dim=2_0_4_8  ,     num_feature_levels=5  ,     assign_first_stage=_A  ,     with_box_refine=_A  ,     two_stage=_A  ,     )

  # set labels
  _a						: int    =			9_1
  _a						: Optional[int]    =			"""huggingface/label-files"""
  _a						: Dict    =			"""coco-detection-id2label.json"""
  _a						: Dict    =			json.load(open(cached_download(hf_hub_url(_A  ,     _A  ,     repo_type="""dataset"""       )       )  ,     """r"""       )       )
  _a						: Optional[Any]    =			{int(_A       ): v for k, v in idalabel.items()}
  _a						: Optional[int]    =			idalabel
  _a						: Any    =			{v: k for k, v in idalabel.items()}

  return config

def     lowerCAmelCase__  (  UpperCamelCase__       ):



  '''simple docstring'''
  _a						: List[Any]    =			[]

  # stem
  # fmt: off
  rename_keys.append(("""backbone.0.body.conv1.weight""", """model.backbone.model.embedder.embedder.convolution.weight""")       )
  rename_keys.append(("""backbone.0.body.bn1.weight""", """model.backbone.model.embedder.embedder.normalization.weight""")       )
  rename_keys.append(("""backbone.0.body.bn1.bias""", """model.backbone.model.embedder.embedder.normalization.bias""")       )
  rename_keys.append(("""backbone.0.body.bn1.running_mean""", """model.backbone.model.embedder.embedder.normalization.running_mean""")       )
  rename_keys.append(("""backbone.0.body.bn1.running_var""", """model.backbone.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"""model.backbone.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"""model.backbone.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"""model.backbone.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"""model.backbone.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"""model.backbone.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"""model.backbone.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"""model.backbone.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"""model.backbone.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"""model.backbone.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"""model.backbone.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_var""",
            )       )
    # 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     lowerCAmelCase__  (  UpperCamelCase__  ,     UpperCamelCase__  ,     UpperCamelCase__       ):



  '''simple docstring'''
  _a						: Optional[Any]    =			dct.pop(_A       )
  _a						: int    =			val

def     lowerCAmelCase__  (  UpperCamelCase__  ,     UpperCamelCase__       ):



  '''simple docstring'''
  _a						: Optional[Any]    =			config.d_model
  for i in range(config.decoder_layers       ):
    # read in weights + bias of input projection layer of self-attention
    _a						: Dict    =			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						: Optional[Any]    =			in_proj_bias[:hidden_size]
    _a						: Optional[int]    =			in_proj_weight[
        hidden_size : hidden_size * 2, :
    ]
    _a						: Tuple    =			in_proj_bias[hidden_size : hidden_size * 2]
    _a						: Optional[Any]    =			in_proj_weight[-hidden_size:, :]
    _a						: Optional[int]    =			in_proj_bias[-hidden_size:]

def     lowerCAmelCase__  (  ):



  '''simple docstring'''
  _a						: str    =			"""http://images.cocodataset.org/val2017/000000039769.jpg"""
  _a						: List[str]    =			Image.open(requests.get(_A  ,     stream=_A       ).raw       )

  return im

@torch.no_grad()
def     lowerCAmelCase__  (  UpperCamelCase__  ,     UpperCamelCase__  ,     UpperCamelCase__       ):



  '''simple docstring'''
  _a						: Optional[int]    =			get_deta_config()

  # load original state dict
  if model_name == "deta-resnet-50":
    _a						: List[str]    =			"""adet_checkpoint0011.pth"""
  elif model_name == "deta-resnet-50-24-epochs":
    _a						: int    =			"""adet_2x_checkpoint0023.pth"""
  else:
    raise ValueError(F"""Model name {model_name} not supported"""       )
  _a						: List[str]    =			hf_hub_download(repo_id="""nielsr/deta-checkpoints"""  ,     filename=_A       )
  _a						: List[str]    =			torch.load(_A  ,     map_location="""cpu"""       )["""model"""]

  # rename keys
  _a						: str    =			create_rename_keys(_A       )
  for src, dest in rename_keys:
    rename_key(_A  ,     _A  ,     _A       )
  read_in_decoder_q_k_v(_A  ,     _A       )

  # 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						: int    =			state_dict.pop(_A       )
      _a						: List[str]    =			val
    if "input_proj" in key:
      _a						: str    =			state_dict.pop(_A       )
      _a						: Tuple    =			val
    if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
      _a						: Optional[Any]    =			state_dict.pop(_A       )
      _a						: Optional[int]    =			val

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

  _a						: Optional[int]    =			"""cuda""" if torch.cuda.is_available() else """cpu"""
  model.to(_A       )

  # load image processor
  _a						: List[Any]    =			DetaImageProcessor(format="""coco_detection"""       )

  # verify our conversion on image
  _a						: Optional[Any]    =			prepare_img()
  _a						: Optional[Any]    =			processor(images=_A  ,     return_tensors="""pt"""       )
  _a						: Union[str, Any]    =			encoding["""pixel_values"""]
  _a						: Tuple    =			model(pixel_values.to(_A       )       )

  # verify logits
  if model_name == "deta-resnet-50":
    _a						: Union[str, Any]    =			torch.tensor(
        [[-7.3_978, -2.5_406, -4.1_668], [-8.2_684, -3.9_933, -3.8_096], [-7.0_515, -3.7_973, -5.8_516]]       )
    _a						: str    =			torch.tensor([[0.5_043, 0.4_973, 0.9_998], [0.2_542, 0.5_489, 0.4_748], [0.5_490, 0.2_765, 0.0_570]]       )
  elif model_name == "deta-resnet-50-24-epochs":
    _a						: Optional[Any]    =			torch.tensor(
        [[-7.1_688, -2.4_857, -4.8_669], [-7.8_630, -3.8_154, -4.2_674], [-7.2_730, -4.1_865, -5.5_323]]       )
    _a						: List[str]    =			torch.tensor([[0.5_021, 0.4_971, 0.9_994], [0.2_546, 0.5_486, 0.4_731], [0.1_686, 0.1_986, 0.2_142]]       )

  assert torch.allclose(outputs.logits[0, :3, :3]  ,     expected_logits.to(_A       )  ,     atol=1e-4       )
  assert torch.allclose(outputs.pred_boxes[0, :3, :3]  ,     expected_boxes.to(_A       )  ,     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(_A       ).mkdir(exist_ok=_A       )
    model.save_pretrained(_A       )
    processor.save_pretrained(_A       )

  # 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					   =     argparse.ArgumentParser()

 parser.add_argument(
     '--model_name',
     type=str,
     default='deta-resnet-50',
     choices=['deta-resnet-50', 'deta-resnet-50-24-epochs'],
     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					   =     parser.parse_args()
 convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)









"""simple docstring"""




import json
import os
from dataclasses import dataclass

import numpy as np
import pyarrow as pa

import datasets
from utils import get_duration


_snake_case					   =     1000_0000_0000
_snake_case					   =     1_0000

_snake_case   ,				_snake_case					   =     os.path.split(__file__)
_snake_case					   =     os.path.join(RESULTS_BASEPATH, 'results', RESULTS_FILENAME.replace('.py', '.json'))

def     lowerCAmelCase__  (  UpperCamelCase__  ,     UpperCamelCase__       ):



  '''simple docstring'''
  _a						: Union[str, Any]    =			pa.Table.from_pydict({"""col""": [0] * chunk_size}       )
  _a						: Dict    =			pa.concat_tables([table] * (num_examples // chunk_size)       )
  return datasets.Dataset(UpperCamelCase__  ,     fingerprint="""table_100B"""       )






@dataclass
class  UpperCamelCase    :
 UpperCamelCase      : int
 UpperCamelCase      : int
 UpperCamelCase      : int
 UpperCamelCase      : int


 def _lowercase			(  self	:		Optional[int]							)      -> Dict:
   _a						: Tuple    =			np.random.default_rng(self.seed							)
   _a						: Dict    =			rng.integers(low=self.low							,		high=self.high							,		size=self.size							).tolist()


 def __iter__(  self	:		List[Any]							)      -> Optional[Any]:
   return iter(self._sampled_values							)







 def __len__(  self	:		Dict							)      -> Optional[Any]:
   return self.size







@get_duration
def     lowerCAmelCase__  (  UpperCamelCase__       ):



  '''simple docstring'''
  _a						: Union[str, Any]    =			dataset[0]

@get_duration
def     lowerCAmelCase__  (  UpperCamelCase__       ):



  '''simple docstring'''
  _a						: Optional[Any]    =			dataset[-1]

@get_duration
def     lowerCAmelCase__  (  UpperCamelCase__       ):



  '''simple docstring'''
  _a						: str    =			dataset[range(len(UpperCamelCase__       ) // 2  ,     len(UpperCamelCase__       ) // 2 + 1_0_2_4       )]

@get_duration
def     lowerCAmelCase__  (  UpperCamelCase__       ):



  '''simple docstring'''
  _a						: Tuple    =			dataset[RandIter(0  ,     len(UpperCamelCase__       )  ,     1_0_2_4  ,     seed=4_2       )]

def     lowerCAmelCase__  (  ):



  '''simple docstring'''
  _a						: str    =			{"""num examples""": SPEED_TEST_N_EXAMPLES}
  _a						: Dict    =			(get_first_row, get_last_row, get_batch_of_aaaa_rows, get_batch_of_aaaa_random_rows)
  print("""generating dataset"""       )
  _a						: List[str]    =			generate_100B_dataset(num_examples=UpperCamelCase__  ,     chunk_size=UpperCamelCase__       )
  print("""Functions"""       )
  for func in functions:
    print(func.__name__       )
    _a						: Optional[Any]    =			func(UpperCamelCase__       )

  with open(UpperCamelCase__  ,     """wb"""       ) as f:
    f.write(json.dumps(UpperCamelCase__       ).encode("""utf-8"""       )       )


if __name__ == "__main__":  # useful to run the profiler
 benchmark_table_100B()

