




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()
__lowerCAmelCase						:							str			     =						logging.get_logger(__name__)




def      __magic_name__							(					A						:   int  ):






			'''simple docstring'''







			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      __magic_name__							(					A						:   Dict  ):






			'''simple docstring'''







			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[:256, :]
						a       =     in_proj_bias[:256]
						a       =     in_proj_weight[256:512, :]
						a       =     in_proj_bias[256:512]
						a       =     in_proj_weight[-256:, :]
						a       =     in_proj_bias[-256:]




def      __magic_name__							(					):






			'''simple docstring'''







			a       =     "http://images.cocodataset.org/val2017/000000039769.jpg"
			a       =     Image.open(requests.get(A,    stream=A  ).raw  )

			return im




@torch.no_grad()
def      __magic_name__							(					A						:   Tuple,    A						:   Any,    A						:   Optional[int],    A						:   Optional[Any],    A						:   Tuple,    A						:   Any,    A						:   str,    ):






			'''simple docstring'''







			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(A,    A,    repo_type="dataset"  )  ),    "r"  )  )
			a       =     {int(A  ): 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=A,    return_tensors="pt"  )
			a       =     encoding["pixel_values"]

			logger.info("Converting model..."  )

			# load original state dict
			a       =     torch.load(A,    map_location="cpu"  )["model"]
			# rename keys
			for key in state_dict.copy().keys():
						a       =     state_dict.pop(A  )
						a       =     val
			# query, key and value matrices need special treatment
			read_in_q_k_v(A  )
			# 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(A  )
									a       =     val
    # finally, create HuggingFace model and load state dict
			a       =     DeformableDetrForObjectDetection(A  )
			model.load_state_dict(A  )
			model.eval()

			a       =     "cuda" if torch.cuda.is_available() else "cpu"
			model.to(A  )
			# verify our conversion
			a       =     model(pixel_values.to(A  )  )

			a       =     torch.tensor(
			    [[-9.66_45, -4.34_49, -5.87_05], [-9.70_35, -3.85_04, -5.07_24], [-10.56_34, -5.33_79, -7.51_16]]  )
			a       =     torch.tensor([[0.86_93, 0.22_89, 0.24_92], [0.31_50, 0.54_89, 0.58_45], [0.55_63, 0.75_80, 0.85_18]]  )

			if single_scale:
						a       =     torch.tensor(
						    [[-9.90_51, -4.25_41, -6.48_52], [-9.69_47, -4.08_54, -6.80_33], [-10.06_65, -5.84_70, -7.70_03]]  )
						a       =     torch.tensor([[0.72_92, 0.49_91, 0.55_32], [0.79_59, 0.24_26, 0.42_36], [0.75_82, 0.35_18, 0.44_51]]  )

			if single_scale and dilation:
						a       =     torch.tensor(
						    [[-8.96_52, -4.10_74, -5.66_35], [-9.05_96, -4.94_47, -6.60_75], [-10.11_78, -4.52_75, -6.26_71]]  )
						a       =     torch.tensor([[0.76_65, 0.41_30, 0.47_69], [0.83_64, 0.18_41, 0.33_91], [0.62_61, 0.38_95, 0.79_78]]  )

			if with_box_refine:
						a       =     torch.tensor(
						    [[-8.88_95, -5.41_87, -6.81_53], [-8.47_06, -6.16_68, -7.61_84], [-9.00_42, -5.53_59, -6.91_41]]  )
						a       =     torch.tensor([[0.78_28, 0.22_08, 0.43_23], [0.08_92, 0.59_96, 0.13_19], [0.55_24, 0.63_89, 0.89_14]]  )

			if with_box_refine and two_stage:
						a       =     torch.tensor(
						    [[-6.71_08, -4.32_13, -6.37_77], [-8.90_14, -6.17_99, -6.72_40], [-6.93_15, -4.47_35, -6.22_98]]  )
						a       =     torch.tensor([[0.25_83, 0.54_99, 0.46_83], [0.76_52, 0.90_68, 0.48_82], [0.54_90, 0.27_63, 0.05_64]]  )

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

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

			# Save model and image processor
			logger.info(F"""Saving PyTorch model and image processor to {pytorch_dump_folder_path}..."""  )
			Path(A  ).mkdir(exist_ok=A  )
			model.save_pretrained(A  )
			image_processor.save_pretrained(A  )

			# 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=A,    organization="nielsr",    commit_message="Add model"  )


if __name__ == "__main__":
		__lowerCAmelCase						:							Optional[Any]			     =						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.'
		)
		__lowerCAmelCase						:							List[str]			     =						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,
		)












import datasets

from .evaluate import (
    apply_no_ans_threshold,
    find_all_best_thresh,
    get_raw_scores,
    make_eval_dict,
    make_qid_to_has_ans,
    merge_eval,
)


__lowerCAmelCase						:							Optional[int]			     =						'\\n@inproceedings{Rajpurkar2016SQuAD10,\n  title={SQuAD: 100, 000+ Questions for Machine Comprehension of Text},\n  author={Pranav Rajpurkar and Jian Zhang and Konstantin Lopyrev and Percy Liang},\n  booktitle={EMNLP},\n  year={2016}\n}\n'

__lowerCAmelCase						:							str			     =						'\nThis metric wrap the official scoring script for version 2 of the Stanford Question\nAnswering Dataset (SQuAD).\n\nStanford Question Answering Dataset (SQuAD) is a reading comprehension dataset, consisting of questions posed by\ncrowdworkers on a set of Wikipedia articles, where the answer to every question is a segment of text, or span,\nfrom the corresponding reading passage, or the question might be unanswerable.\n\nSQuAD2.0 combines the 100,000 questions in SQuAD1.1 with over 50,000 unanswerable questions\nwritten adversarially by crowdworkers to look similar to answerable ones.\nTo do well on SQuAD2.0, systems must not only answer questions when possible, but also\ndetermine when no answer is supported by the paragraph and abstain from answering.\n'

__lowerCAmelCase						:							Optional[Any]			     =						'\nComputes SQuAD v2 scores (F1 and EM).\nArgs:\n    predictions: List of triple for question-answers to score with the following elements:\n        - the question-answer \'id\' field as given in the references (see below)\n        - the text of the answer\n        - the probability that the question has no answer\n    references: List of question-answers dictionaries with the following key-values:\n            - \'id\': id of the question-answer pair (see above),\n            - \'answers\': a list of Dict {\'text\': text of the answer as a string}\n    no_answer_threshold: float\n        Probability threshold to decide that a question has no answer.\nReturns:\n    \'exact\': Exact match (the normalized answer exactly match the gold answer)\n    \'f1\': The F-score of predicted tokens versus the gold answer\n    \'total\': Number of score considered\n    \'HasAns_exact\': Exact match (the normalized answer exactly match the gold answer)\n    \'HasAns_f1\': The F-score of predicted tokens versus the gold answer\n    \'HasAns_total\': Number of score considered\n    \'NoAns_exact\': Exact match (the normalized answer exactly match the gold answer)\n    \'NoAns_f1\': The F-score of predicted tokens versus the gold answer\n    \'NoAns_total\': Number of score considered\n    \'best_exact\': Best exact match (with varying threshold)\n    \'best_exact_thresh\': No-answer probability threshold associated to the best exact match\n    \'best_f1\': Best F1 (with varying threshold)\n    \'best_f1_thresh\': No-answer probability threshold associated to the best F1\nExamples:\n\n    >>> predictions = [{\'prediction_text\': \'1976\', \'id\': \'56e10a3be3433e1400422b22\', \'no_answer_probability\': 0.}]\n    >>> references = [{\'answers\': {\'answer_start\': [97], \'text\': [\'1976\']}, \'id\': \'56e10a3be3433e1400422b22\'}]\n    >>> squad_v2_metric = datasets.load_metric("squad_v2")\n    >>> results = squad_v2_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'exact\': 100.0, \'f1\': 100.0, \'total\': 1, \'HasAns_exact\': 100.0, \'HasAns_f1\': 100.0, \'HasAns_total\': 1, \'best_exact\': 100.0, \'best_exact_thresh\': 0.0, \'best_f1\': 100.0, \'best_f1_thresh\': 0.0}\n'




@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION       ,			_KWARGS_DESCRIPTION  )
class        snake_case__				(datasets.Metric  ):
				"""simple docstring"""



				def 				__UpperCAmelCase				( self							:	List[str]				)   ->	Union[str, Any]:
							return datasets.MetricInfo(
							    description=_DESCRIPTION   , citation=_CITATION   , inputs_description=_KWARGS_DESCRIPTION   , features=datasets.Features(
							        {
							            "predictions": {
							                "id": datasets.Value("string"				),
							                "prediction_text": datasets.Value("string"				),
							                "no_answer_probability": datasets.Value("float32"				),
							            },
							            "references": {
							                "id": datasets.Value("string"				),
							                "answers": datasets.features.Sequence(
							                    {"text": datasets.Value("string"				), "answer_start": datasets.Value("int32"				)}				),
							            },
							        }				)   , codebase_urls=["https://rajpurkar.github.io/SQuAD-explorer/"]   , reference_urls=["https://rajpurkar.github.io/SQuAD-explorer/"]   , )





				def 				__UpperCAmelCase				( self							:	List[str]   , __lowerCamelCase							:	Tuple   , __lowerCamelCase							:	Optional[Any]   , __lowerCamelCase							:	Dict=1.0				)   ->	List[str]:
							a       =     {p["id"]: p["no_answer_probability"] for p in predictions}
							a       =     [{"paragraphs": [{"qas": references}]}]
							a       =     {p["id"]: p["prediction_text"] for p in predictions}

							a       =     make_qid_to_has_ans(__lowerCamelCase				)  # maps qid to True/False
							a       =     [k for k, v in qid_to_has_ans.items() if v]
							a       =     [k for k, v in qid_to_has_ans.items() if not v]

							a       ,						a       =     get_raw_scores(__lowerCamelCase   , __lowerCamelCase				)
							a       =     apply_no_ans_threshold(__lowerCamelCase   , __lowerCamelCase   , __lowerCamelCase   , __lowerCamelCase				)
							a       =     apply_no_ans_threshold(__lowerCamelCase   , __lowerCamelCase   , __lowerCamelCase   , __lowerCamelCase				)
							a       =     make_eval_dict(__lowerCamelCase   , __lowerCamelCase				)

							if has_ans_qids:
										a       =     make_eval_dict(__lowerCamelCase   , __lowerCamelCase   , qid_list=__lowerCamelCase				)
										merge_eval(__lowerCamelCase   , __lowerCamelCase   , "HasAns"				)
							if no_ans_qids:
										a       =     make_eval_dict(__lowerCamelCase   , __lowerCamelCase   , qid_list=__lowerCamelCase				)
										merge_eval(__lowerCamelCase   , __lowerCamelCase   , "NoAns"				)
							find_all_best_thresh(__lowerCamelCase   , __lowerCamelCase   , __lowerCamelCase   , __lowerCamelCase   , __lowerCamelCase   , __lowerCamelCase				)
							return dict(__lowerCamelCase				)






