'''simple docstring'''




import argparse
import json
from pathlib import Path

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

from transformers import DeformableDetrConfig, DeformableDetrForObjectDetection, DeformableDetrImageProcessor
from transformers.utils import logging


logging.set_verbosity_info()
__snake_case  : str		       =    logging.get_logger(__name__)





def 	_UpperCAmelCase       (				_UpperCamelCase       :      Optional[Any]  )      -> Any:
    if "backbone.0.body" in orig_key:
        A_      =  orig_key.replace('''backbone.0.body''',  '''backbone.conv_encoder.model'''  )
    if "transformer" in orig_key:
        A_      =  orig_key.replace('''transformer.''',  ''''''  )
    if "norm1" in orig_key:
        if "encoder" in orig_key:
            A_      =  orig_key.replace('''norm1''',  '''self_attn_layer_norm'''  )
        else:
            A_      =  orig_key.replace('''norm1''',  '''encoder_attn_layer_norm'''  )
    if "norm2" in orig_key:
        if "encoder" in orig_key:
            A_      =  orig_key.replace('''norm2''',  '''final_layer_norm'''  )
        else:
            A_      =  orig_key.replace('''norm2''',  '''self_attn_layer_norm'''  )
    if "norm3" in orig_key:
        A_      =  orig_key.replace('''norm3''',  '''final_layer_norm'''  )
    if "linear1" in orig_key:
        A_      =  orig_key.replace('''linear1''',  '''fc1'''  )
    if "linear2" in orig_key:
        A_      =  orig_key.replace('''linear2''',  '''fc2'''  )
    if "query_embed" in orig_key:
        A_      =  orig_key.replace('''query_embed''',  '''query_position_embeddings'''  )
    if "cross_attn" in orig_key:
        A_      =  orig_key.replace('''cross_attn''',  '''encoder_attn'''  )

    return orig_key





def 	_UpperCAmelCase       (				_UpperCamelCase       :      Optional[Any]  )      -> List[str]:
    # transformer decoder self-attention layers
    for i in range(6  ):
        # read in weights + bias of input projection layer of self-attention
        A_      =  state_dict.pop(F'''decoder.layers.{i}.self_attn.in_proj_weight'''  )
        A_      =  state_dict.pop(F'''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[:2_56, :]
        A_      =  in_proj_bias[:2_56]
        A_      =  in_proj_weight[2_56:5_12, :]
        A_      =  in_proj_bias[2_56:5_12]
        A_      =  in_proj_weight[-2_56:, :]
        A_      =  in_proj_bias[-2_56:]





def 	_UpperCAmelCase       (				)      -> Any:
    A_      =  '''http://images.cocodataset.org/val2017/000000039769.jpg'''
    A_      =  Image.open(requests.get(_UpperCamelCase,  stream=_UpperCamelCase  ).raw  )

    return im





@torch.no_grad()
def 	_UpperCAmelCase       (				_UpperCamelCase       :      List[Any],  _UpperCamelCase       :      Any,  _UpperCamelCase       :      str,  _UpperCamelCase       :      int,  _UpperCamelCase       :      Tuple,  _UpperCamelCase       :      List[Any],  _UpperCamelCase       :      Union[str, Any],  )      -> int:
    A_      =  DeformableDetrConfig()
    # set config attributes
    if single_scale:
        A_      =  1
    A_      =  dilation
    A_      =  with_box_refine
    A_      =  two_stage
    # set labels
    A_      =  91
    A_      =  '''huggingface/label-files'''
    A_      =  '''coco-detection-id2label.json'''
    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()}

    # load image processor
    A_      =  DeformableDetrImageProcessor(format='''coco_detection'''  )

    # prepare image
    A_      =  prepare_img()
    A_      =  image_processor(images=_UpperCamelCase,  return_tensors='''pt'''  )
    A_      =  encoding['''pixel_values''']

    logger.info('''Converting model...'''  )

    # load original state dict
    A_      =  torch.load(_UpperCamelCase,  map_location='''cpu'''  )['''model''']
    # rename keys
    for key in state_dict.copy().keys():
        A_      =  state_dict.pop(_UpperCamelCase  )
        A_      =  val
    # query, key and value matrices need special treatment
    read_in_q_k_v(_UpperCamelCase  )
    # important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
    A_      =  '''model.'''
    for key in state_dict.copy().keys():
        if not key.startswith('''class_embed'''  ) and not key.startswith('''bbox_embed'''  ):
            A_      =  state_dict.pop(_UpperCamelCase  )
            A_      =  val
    # finally, create HuggingFace model and load state dict
    A_      =  DeformableDetrForObjectDetection(_UpperCamelCase  )
    model.load_state_dict(_UpperCamelCase  )
    model.eval()

    A_      =  '''cuda''' if torch.cuda.is_available() else '''cpu'''
    model.to(_UpperCamelCase  )
    # verify our conversion
    A_      =  model(pixel_values.to(_UpperCamelCase  )  )

    A_      =  torch.tensor(
        [[-9.6_6_4_5, -4.3_4_4_9, -5.8_7_0_5], [-9.7_0_3_5, -3.8_5_0_4, -5.0_7_2_4], [-1_0.5_6_3_4, -5.3_3_7_9, -7.5_1_1_6]]  )
    A_      =  torch.tensor([[0.8_6_9_3, 0.2_2_8_9, 0.2_4_9_2], [0.3_1_5_0, 0.5_4_8_9, 0.5_8_4_5], [0.5_5_6_3, 0.7_5_8_0, 0.8_5_1_8]]  )

    if single_scale:
        A_      =  torch.tensor(
            [[-9.9_0_5_1, -4.2_5_4_1, -6.4_8_5_2], [-9.6_9_4_7, -4.0_8_5_4, -6.8_0_3_3], [-1_0.0_6_6_5, -5.8_4_7_0, -7.7_0_0_3]]  )
        A_      =  torch.tensor([[0.7_2_9_2, 0.4_9_9_1, 0.5_5_3_2], [0.7_9_5_9, 0.2_4_2_6, 0.4_2_3_6], [0.7_5_8_2, 0.3_5_1_8, 0.4_4_5_1]]  )

    if single_scale and dilation:
        A_      =  torch.tensor(
            [[-8.9_6_5_2, -4.1_0_7_4, -5.6_6_3_5], [-9.0_5_9_6, -4.9_4_4_7, -6.6_0_7_5], [-1_0.1_1_7_8, -4.5_2_7_5, -6.2_6_7_1]]  )
        A_      =  torch.tensor([[0.7_6_6_5, 0.4_1_3_0, 0.4_7_6_9], [0.8_3_6_4, 0.1_8_4_1, 0.3_3_9_1], [0.6_2_6_1, 0.3_8_9_5, 0.7_9_7_8]]  )

    if with_box_refine:
        A_      =  torch.tensor(
            [[-8.8_8_9_5, -5.4_1_8_7, -6.8_1_5_3], [-8.4_7_0_6, -6.1_6_6_8, -7.6_1_8_4], [-9.0_0_4_2, -5.5_3_5_9, -6.9_1_4_1]]  )
        A_      =  torch.tensor([[0.7_8_2_8, 0.2_2_0_8, 0.4_3_2_3], [0.0_8_9_2, 0.5_9_9_6, 0.1_3_1_9], [0.5_5_2_4, 0.6_3_8_9, 0.8_9_1_4]]  )

    if with_box_refine and two_stage:
        A_      =  torch.tensor(
            [[-6.7_1_0_8, -4.3_2_1_3, -6.3_7_7_7], [-8.9_0_1_4, -6.1_7_9_9, -6.7_2_4_0], [-6.9_3_1_5, -4.4_7_3_5, -6.2_2_9_8]]  )
        A_      =  torch.tensor([[0.2_5_8_3, 0.5_4_9_9, 0.4_6_8_3], [0.7_6_5_2, 0.9_0_6_8, 0.4_8_8_2], [0.5_4_9_0, 0.2_7_6_3, 0.0_5_6_4]]  )

    print('''Logits:''',  outputs.logits[0, :3, :3]  )

    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!'''  )

    # 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  )
    image_processor.save_pretrained(_UpperCamelCase  )

    # Push to hub
    if push_to_hub:
        A_      =  '''deformable-detr'''
        model_name += "-single-scale" if single_scale else ""
        model_name += "-dc5" if dilation else ""
        model_name += "-with-box-refine" if with_box_refine else ""
        model_name += "-two-stage" if two_stage else ""
        print('''Pushing model to hub...'''  )
        model.push_to_hub(repo_path_or_name=_UpperCamelCase,  organization='''nielsr''',  commit_message='''Add model'''  )


if __name__ == "__main__":
  __snake_case  : Optional[int]		       =    argparse.ArgumentParser()

  parser.add_argument(
      '--checkpoint_path',
      type=str,
      default='/home/niels/checkpoints/deformable_detr/r50_deformable_detr-checkpoint.pth',
      help='Path to Pytorch checkpoint (.pth file) you\'d like to convert.',
  )
  parser.add_argument('--single_scale', action='store_true', help='Whether to set config.num_features_levels = 1.')
  parser.add_argument('--dilation', action='store_true', help='Whether to set config.dilation=True.')
  parser.add_argument('--with_box_refine', action='store_true', help='Whether to set config.with_box_refine=True.')
  parser.add_argument('--two_stage', action='store_true', help='Whether to set config.two_stage=True.')
  parser.add_argument(
      '--pytorch_dump_folder_path',
      default=None,
      type=str,
      required=True,
      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_deformable_detr_checkpoint(
      args.checkpoint_path,
      args.single_scale,
      args.dilation,
      args.with_box_refine,
      args.two_stage,
      args.pytorch_dump_folder_path,
      args.push_to_hub,
  )







'''simple docstring'''




from __future__ import annotations

import unittest

from transformers import OpenAIGPTConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
  import tensorflow as tf

  from transformers.models.openai.modeling_tf_openai import (
      TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFOpenAIGPTDoubleHeadsModel,
      TFOpenAIGPTForSequenceClassification,
      TFOpenAIGPTLMHeadModel,
      TFOpenAIGPTModel,
  )




class       __UpperCAmelCase							:





       '''simple docstring'''



       def __init__( self       ,	_SCREAMING_SNAKE_CASE       ,	)						->	Any:
           A_      =  parent
           A_      =  13
           A_      =  7
           A_      =  True
           A_      =  True
           A_      =  True
           A_      =  True
           A_      =  True
           A_      =  99
           A_      =  32
           A_      =  2
           A_      =  4
           A_      =  37
           A_      =  '''gelu'''
           A_      =  0.1
           A_      =  0.1
           A_      =  512
           A_      =  16
           A_      =  2
           A_      =  0.02
           A_      =  3
           A_      =  4
           A_      =  None
           A_      =  self.vocab_size - 1

       def    __A			( self					)						->	Union[str, Any]:
           A_      =  ids_tensor([self.batch_size, self.seq_length]       ,	self.vocab_size					)

           A_      =  None
           if self.use_input_mask:
               A_      =  random_attention_mask([self.batch_size, self.seq_length]					)

           A_      =  None
           if self.use_token_type_ids:
               A_      =  ids_tensor([self.batch_size, self.seq_length]       ,	self.type_vocab_size					)

           A_      =  None
           if self.use_mc_token_ids:
               A_      =  ids_tensor([self.batch_size, self.num_choices]       ,	self.seq_length					)

           A_      =  None
           A_      =  None
           A_      =  None
           if self.use_labels:
               A_      =  ids_tensor([self.batch_size]       ,	self.type_sequence_label_size					)
               A_      =  ids_tensor([self.batch_size, self.seq_length]       ,	self.num_labels					)
               A_      =  ids_tensor([self.batch_size]       ,	self.num_choices					)

           A_      =  OpenAIGPTConfig(
               vocab_size=self.vocab_size       ,	n_embd=self.hidden_size       ,	n_layer=self.num_hidden_layers       ,	n_head=self.num_attention_heads       ,	n_positions=self.max_position_embeddings       ,	pad_token_id=self.pad_token_id       ,	)

           A_      =  ids_tensor([self.num_hidden_layers, self.num_attention_heads]       ,	2					)

           return (
               config,
               input_ids,
               input_mask,
               head_mask,
               token_type_ids,
               mc_token_ids,
               sequence_labels,
               token_labels,
               choice_labels,
           )

       def    __A			( self       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	*_SCREAMING_SNAKE_CASE					)						->	Optional[int]:
           A_      =  TFOpenAIGPTModel(config=_SCREAMING_SNAKE_CASE					)
           A_      =  {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
           A_      =  model(_SCREAMING_SNAKE_CASE					)

           A_      =  [input_ids, input_mask]
           A_      =  model(_SCREAMING_SNAKE_CASE					)

           A_      =  model(_SCREAMING_SNAKE_CASE					)

           self.parent.assertEqual(result.last_hidden_state.shape       ,	(self.batch_size, self.seq_length, self.hidden_size)					)

       def    __A			( self       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	*_SCREAMING_SNAKE_CASE					)						->	Dict:
           A_      =  TFOpenAIGPTLMHeadModel(config=_SCREAMING_SNAKE_CASE					)
           A_      =  {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
           A_      =  model(_SCREAMING_SNAKE_CASE					)
           self.parent.assertEqual(result.logits.shape       ,	(self.batch_size, self.seq_length, self.vocab_size)					)

       def    __A			( self       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	*_SCREAMING_SNAKE_CASE					)						->	Optional[Any]:
           A_      =  TFOpenAIGPTDoubleHeadsModel(config=_SCREAMING_SNAKE_CASE					)

           A_      =  tf.tile(tf.expand_dims(_SCREAMING_SNAKE_CASE       ,	1					)       ,	(1, self.num_choices, 1)					)
           A_      =  tf.tile(tf.expand_dims(_SCREAMING_SNAKE_CASE       ,	1					)       ,	(1, self.num_choices, 1)					)
           A_      =  tf.tile(tf.expand_dims(_SCREAMING_SNAKE_CASE       ,	1					)       ,	(1, self.num_choices, 1)					)

           A_      =  {
               '''input_ids''': multiple_choice_inputs_ids,
               '''mc_token_ids''': mc_token_ids,
               '''attention_mask''': multiple_choice_input_mask,
               '''token_type_ids''': multiple_choice_token_type_ids,
           }
           A_      =  model(_SCREAMING_SNAKE_CASE					)
           self.parent.assertEqual(
               result.logits.shape       ,	(self.batch_size, self.num_choices, self.seq_length, self.vocab_size)					)
           self.parent.assertEqual(result.mc_logits.shape       ,	(self.batch_size, self.num_choices)					)

       def    __A			( self       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	*_SCREAMING_SNAKE_CASE					)						->	Dict:
           A_      =  self.num_labels
           A_      =  ids_tensor([self.batch_size]       ,	self.type_sequence_label_size					)
           A_      =  {
               '''input_ids''': input_ids,
               '''attention_mask''': input_mask,
               '''token_type_ids''': token_type_ids,
               '''labels''': sequence_labels,
           }
           A_      =  TFOpenAIGPTForSequenceClassification(_SCREAMING_SNAKE_CASE					)
           A_      =  model(_SCREAMING_SNAKE_CASE					)
           self.parent.assertEqual(result.logits.shape       ,	(self.batch_size, self.num_labels)					)

       def    __A			( self					)						->	Union[str, Any]:
           A_      =  self.prepare_config_and_inputs()

           (
               (
               A_
           )  ,(
               A_
           )  ,(
               A_
           )  ,(
               A_
           )  ,(
               A_
           )  ,(
               A_
           )  ,(
               A_
           )  ,(
               A_
           )  ,(
               A_
           )  ,
           )      =  config_and_inputs

           A_      =  {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
           return config, inputs_dict




@require_tf
class       __UpperCAmelCase							(							_UpperCamelCase		, _UpperCamelCase		, unittest.TestCase	):





       '''simple docstring'''



       __lowercase   :   Dict  					=							(
           (TFOpenAIGPTModel, TFOpenAIGPTLMHeadModel, TFOpenAIGPTDoubleHeadsModel, TFOpenAIGPTForSequenceClassification)
           if is_tf_available()
           else ()
       )
       __lowercase   :   List[str]  					=							(
           (TFOpenAIGPTLMHeadModel,) if is_tf_available() else ()
       )  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
       __lowercase   :   List[str]  					=							(
           {
               'feature-extraction': TFOpenAIGPTModel,
               'text-classification': TFOpenAIGPTForSequenceClassification,
               'text-generation': TFOpenAIGPTLMHeadModel,
               'zero-shot': TFOpenAIGPTForSequenceClassification,
           }
           if is_tf_available()
           else {}
       )
       __lowercase   :   Dict  					=							False
       __lowercase   :   Optional[int]  					=							False

       def    __A			( self       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE					)						->	Union[str, Any]:
           if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
               # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
               # `OpenAIGPTConfig` was never used in pipeline tests, either because of a missing checkpoint or because a
               # tiny config could not be created.
               return True

           return False

       def    __A			( self					)						->	Any:
           A_      =  TFOpenAIGPTModelTester(self					)
           A_      =  ConfigTester(self       ,	config_class=_SCREAMING_SNAKE_CASE       ,	n_embd=37					)

       def    __A			( self					)						->	List[Any]:
           self.config_tester.run_common_tests()

       def    __A			( self					)						->	Dict:
           A_      =  self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_openai_gpt_model(*_SCREAMING_SNAKE_CASE					)

       def    __A			( self					)						->	Any:
           A_      =  self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_openai_gpt_lm_head(*_SCREAMING_SNAKE_CASE					)

       def    __A			( self					)						->	Tuple:
           A_      =  self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_openai_gpt_double_head(*_SCREAMING_SNAKE_CASE					)

       def    __A			( self					)						->	List[str]:
           A_      =  self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*_SCREAMING_SNAKE_CASE					)

       @slow
       def    __A			( self					)						->	Union[str, Any]:
           for model_name in TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               A_      =  TFOpenAIGPTModel.from_pretrained(_SCREAMING_SNAKE_CASE					)
               self.assertIsNotNone(_SCREAMING_SNAKE_CASE					)




@require_tf
class       __UpperCAmelCase							(							unittest.TestCase	):





       '''simple docstring'''



       @slow
       def    __A			( self					)						->	List[str]:
           A_      =  TFOpenAIGPTLMHeadModel.from_pretrained('''openai-gpt'''					)
           A_      =  tf.convert_to_tensor([[481, 4735, 544]]       ,	dtype=tf.intaa					)  # the president is
           A_      =  [
               481,
               4735,
               544,
               246,
               963,
               870,
               762,
               239,
               244,
               4_0477,
               244,
               249,
               719,
               881,
               487,
               544,
               240,
               244,
               603,
               481,
           ]  # the president is a very good man. " \n " i\'m sure he is, " said the

           A_      =  model.generate(_SCREAMING_SNAKE_CASE       ,	do_sample=_SCREAMING_SNAKE_CASE					)
           self.assertListEqual(output_ids[0].numpy().tolist()       ,	_SCREAMING_SNAKE_CASE					)






