






import logging
import os
from dataclasses import dataclass, field
from typing import Dict, List, Optional

import numpy as np
import torch
from utils_hans import HansDataset, InputFeatures, hans_processors, hans_tasks_num_labels

import transformers
from transformers import (
    AutoConfig,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    default_data_collator,
    set_seed,
)
from transformers.trainer_utils import is_main_process


__UpperCAmelCase      				=							logging.getLogger(__name__)
@dataclass
class 					a_:



     """simple docstring"""



     __snake_case						:							str       			=field(
         metadata={'''help''': '''Path to pretrained model or model identifier from huggingface.co/models'''}					)
     __snake_case						:							Optional[str]       			=field(
         default=lowercase__	,    metadata={'''help''': '''Pretrained config name or path if not the same as model_name'''}					)
     __snake_case						:							Optional[str]       			=field(
         default=lowercase__	,    metadata={'''help''': '''Pretrained tokenizer name or path if not the same as model_name'''}					)
     __snake_case						:							Optional[str]       			=field(
         default=lowercase__	,    metadata={'''help''': '''Where do you want to store the pretrained models downloaded from huggingface.co'''}	,    )

@dataclass
class 					a_:



     """simple docstring"""



     __snake_case						:							str       			=field(
         metadata={'''help''': '''The name of the task to train selected in the list: ''' + ''', '''.join(hans_processors.keys()					)}					)
     __snake_case						:							str       			=field(
         metadata={'''help''': '''The input data dir. Should contain the .tsv files (or other data files) for the task.'''}					)
     __snake_case						:							int       			=field(
         default=1_28	,    metadata={
             '''help''': (
                 '''The maximum total input sequence length after tokenization. Sequences longer '''
                 '''than this will be truncated, sequences shorter will be padded.'''
             )
         }	,    )
     __snake_case						:							bool       			=field(
         default=lowercase__	,    metadata={'''help''': '''Overwrite the cached training and evaluation sets'''}					)





def 		A_			(		lowercase_	)							->Dict[str, torch.Tensor]:







 """simple docstring"""

 SCREAMING_SNAKE_CASE							  =						default_data_collator(lowercase_	)
 SCREAMING_SNAKE_CASE							  =						batch.pop('pairID'					,       lowercase_	)
 return batch





def 		A_			(		)							->List[str]:







 """simple docstring"""

 SCREAMING_SNAKE_CASE							  =						HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)	)
 SCREAMING_SNAKE_CASE  , SCREAMING_SNAKE_CASE  , SCREAMING_SNAKE_CASE							  =						parser.parse_args_into_dataclasses()

 if (
     os.path.exists(training_args.output_dir	)
     and os.listdir(training_args.output_dir	)
     and training_args.do_train
     and not training_args.overwrite_output_dir
 ):
  raise ValueError(
      f'''Output directory ({training_args.output_dir}) already exists and is not empty. Use'''
      ' --overwrite_output_dir to overcome.'	)

 # Setup logging
 logging.basicConfig(
     format='%(asctime)s - %(levelname)s - %(name)s - %(message)s'					,       datefmt='%m/%d/%Y %H:%M:%S'					,       level=logging.INFO if training_args.local_rank in [-1, 0] else logging.WARN					,       )
 logger.warning(
     'Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, 16-bits training: %s'					,       training_args.local_rank					,       training_args.device					,       training_args.n_gpu					,       bool(training_args.local_rank != -1	)					,       training_args.fpaa					,       )
 # Set the verbosity to info of the Transformers logger (on main process only):
 if is_main_process(training_args.local_rank	):
  transformers.utils.logging.set_verbosity_info()
  transformers.utils.logging.enable_default_handler()
  transformers.utils.logging.enable_explicit_format()
 logger.info('Training/evaluation parameters %s'					,       lowercase_	)

 # Set seed
 set_seed(training_args.seed	)

 try:
  SCREAMING_SNAKE_CASE							  =						hans_tasks_num_labels[data_args.task_name]
 except KeyError:
  raise ValueError('Task not found: %s' % (data_args.task_name)	)

 # Load pretrained model and tokenizer
 #
 # Distributed training:
 # The .from_pretrained methods guarantee that only one local process can concurrently
 # download model & vocab.

 SCREAMING_SNAKE_CASE							  =						AutoConfig.from_pretrained(
     model_args.config_name if model_args.config_name else model_args.model_name_or_path					,       num_labels=lowercase_					,       finetuning_task=data_args.task_name					,       cache_dir=model_args.cache_dir					,       )
 SCREAMING_SNAKE_CASE							  =						AutoTokenizer.from_pretrained(
     model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path					,       cache_dir=model_args.cache_dir					,       )
 SCREAMING_SNAKE_CASE							  =						AutoModelForSequenceClassification.from_pretrained(
     model_args.model_name_or_path					,       from_tf=bool('.ckpt' in model_args.model_name_or_path	)					,       config=lowercase_					,       cache_dir=model_args.cache_dir					,       )

 # Get datasets
 SCREAMING_SNAKE_CASE							  =						(
     HansDataset(
         data_dir=data_args.data_dir					,       tokenizer=lowercase_					,       task=data_args.task_name					,       max_seq_length=data_args.max_seq_length					,       overwrite_cache=data_args.overwrite_cache					,       )
     if training_args.do_train
     else None
 )
 SCREAMING_SNAKE_CASE							  =						(
     HansDataset(
         data_dir=data_args.data_dir					,       tokenizer=lowercase_					,       task=data_args.task_name					,       max_seq_length=data_args.max_seq_length					,       overwrite_cache=data_args.overwrite_cache					,       evaluate=lowercase_					,       )
     if training_args.do_eval
     else None
 )

 # Initialize our Trainer
 SCREAMING_SNAKE_CASE							  =						Trainer(
     model=lowercase_					,       args=lowercase_					,       train_dataset=lowercase_					,       eval_dataset=lowercase_					,       data_collator=lowercase_					,       )

 # Training
 if training_args.do_train:
  trainer.train(
      model_path=model_args.model_name_or_path if os.path.isdir(model_args.model_name_or_path	) else None	)
  trainer.save_model()
  # For convenience, we also re-save the tokenizer to the same directory,
  # so that you can share your model easily on huggingface.co/models =)
  if trainer.is_world_master():
   tokenizer.save_pretrained(training_args.output_dir	)

    # Evaluation
 if training_args.do_eval:
  logger.info('*** Evaluate ***'	)

  SCREAMING_SNAKE_CASE							  =						trainer.predict(lowercase_	)
  SCREAMING_SNAKE_CASE							  =						output.predictions
  SCREAMING_SNAKE_CASE							  =						np.argmax(lowercase_					,       axis=1	)

  SCREAMING_SNAKE_CASE							  =						[ex.pairID for ex in eval_dataset]
  SCREAMING_SNAKE_CASE							  =						os.path.join(training_args.output_dir					,       'hans_predictions.txt'	)
  SCREAMING_SNAKE_CASE							  =						eval_dataset.get_labels()
  if trainer.is_world_master():
   with open(lowercase_					,       'w'	) as writer:
    writer.write('pairID,gold_label\n'	)
    for pid, pred in zip(lowercase_					,       lowercase_	):
     writer.write('ex' + str(lowercase_	) + ',' + label_list[int(lowercase_	)] + '\n'	)

  trainer._log(output.metrics	)





def 		A_			(		lowercase_	)							->int:







 """simple docstring"""

 main()


if __name__ == "__main__":
      main()












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





def 		A_			(		lowercase_	)							->Tuple:







 """simple docstring"""

 if "backbone.0.body" in orig_key:
  SCREAMING_SNAKE_CASE							  =						orig_key.replace('backbone.0.body'					,       'backbone.conv_encoder.model'	)
 if "transformer" in orig_key:
  SCREAMING_SNAKE_CASE							  =						orig_key.replace('transformer.'					,       ''	)
 if "norm1" in orig_key:
  if "encoder" in orig_key:
   SCREAMING_SNAKE_CASE							  =						orig_key.replace('norm1'					,       'self_attn_layer_norm'	)
  else:
   SCREAMING_SNAKE_CASE							  =						orig_key.replace('norm1'					,       'encoder_attn_layer_norm'	)
 if "norm2" in orig_key:
  if "encoder" in orig_key:
   SCREAMING_SNAKE_CASE							  =						orig_key.replace('norm2'					,       'final_layer_norm'	)
  else:
   SCREAMING_SNAKE_CASE							  =						orig_key.replace('norm2'					,       'self_attn_layer_norm'	)
 if "norm3" in orig_key:
  SCREAMING_SNAKE_CASE							  =						orig_key.replace('norm3'					,       'final_layer_norm'	)
 if "linear1" in orig_key:
  SCREAMING_SNAKE_CASE							  =						orig_key.replace('linear1'					,       'fc1'	)
 if "linear2" in orig_key:
  SCREAMING_SNAKE_CASE							  =						orig_key.replace('linear2'					,       'fc2'	)
 if "query_embed" in orig_key:
  SCREAMING_SNAKE_CASE							  =						orig_key.replace('query_embed'					,       'query_position_embeddings'	)
 if "cross_attn" in orig_key:
  SCREAMING_SNAKE_CASE							  =						orig_key.replace('cross_attn'					,       'encoder_attn'	)

 return orig_key





def 		A_			(		lowercase_	)							->Dict:







 """simple docstring"""

 for i in range(6	):
  # read in weights + bias of input projection layer of self-attention
  SCREAMING_SNAKE_CASE							  =						state_dict.pop(f'''decoder.layers.{i}.self_attn.in_proj_weight'''	)
  SCREAMING_SNAKE_CASE							  =						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
  SCREAMING_SNAKE_CASE							  =						in_proj_weight[:2_5_6, :]
  SCREAMING_SNAKE_CASE							  =						in_proj_bias[:2_5_6]
  SCREAMING_SNAKE_CASE							  =						in_proj_weight[2_5_6:5_1_2, :]
  SCREAMING_SNAKE_CASE							  =						in_proj_bias[2_5_6:5_1_2]
  SCREAMING_SNAKE_CASE							  =						in_proj_weight[-2_5_6:, :]
  SCREAMING_SNAKE_CASE							  =						in_proj_bias[-2_5_6:]





def 		A_			(		)							->Union[str, Any]:







 """simple docstring"""

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

 return im





@torch.no_grad()
def 		A_			(		lowercase_					,       lowercase_					,       lowercase_					,       lowercase_					,       lowercase_					,       lowercase_					,       lowercase_					,       )							->int:







 """simple docstring"""

 SCREAMING_SNAKE_CASE							  =						DeformableDetrConfig()
 # set config attributes
 if single_scale:
  SCREAMING_SNAKE_CASE							  =						1
 SCREAMING_SNAKE_CASE							  =						dilation
 SCREAMING_SNAKE_CASE							  =						with_box_refine
 SCREAMING_SNAKE_CASE							  =						two_stage
 # set labels
 SCREAMING_SNAKE_CASE							  =						9_1
 SCREAMING_SNAKE_CASE							  =						'huggingface/label-files'
 SCREAMING_SNAKE_CASE							  =						'coco-detection-id2label.json'
 SCREAMING_SNAKE_CASE							  =						json.load(open(cached_download(hf_hub_url(lowercase_					,       lowercase_					,       repo_type='dataset'	)	)					,       'r'	)	)
 SCREAMING_SNAKE_CASE							  =						{int(lowercase_	): v for k, v in idalabel.items()}
 SCREAMING_SNAKE_CASE							  =						idalabel
 SCREAMING_SNAKE_CASE							  =						{v: k for k, v in idalabel.items()}

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

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

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

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

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

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

 # Push to hub
 if push_to_hub:
  SCREAMING_SNAKE_CASE							  =						'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=lowercase_					,       organization='nielsr'					,       commit_message='Add model'	)


if __name__ == "__main__":
      __UpperCAmelCase      				=							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."
      )
      __UpperCAmelCase      				=							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,
      )




